// $ANTLR 3.2 Sep 23, 2009 12:02:23 /home/alex/Desktop/Go.g 2010-03-21 05:47:25

import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
import org.antlr.runtime.debug.*;
import java.io.IOException;
public class GoParser extends DebugParser {
    public static final String[] tokenNames = new String[] {
        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "Unicode_char", "Unicode_letter", "Unicode_digit", "Letter", "Decimal_digit", "Octal_digit", "Hex_digit", "LINE_COMMENT", "COMMENT", "WS", "Identifier", "Decimal_lit", "Octal_lit", "Hex_lit", "Int_lit", "Decimals", "Exponent", "Float_lit", "Imaginary_lit", "Unicode_value", "Byte_value", "Char_lit", "Little_u_value", "Big_u_value", "Escaped_char", "Octal_byte_value", "Hex_byte_value", "Raw_string_lit", "Interpreted_string_lit", "String_lit", "Binary_op", "Unary_op", "Log_op", "Com_op", "Rel_op", "Add_op", "Mul_op", "Assign_op", "'('", "')'", "'['", "']'", "'struct'", "'{'", "';'", "'}'", "'*'", "'func'", "','", "'...'", "'interface'", "'map'", "'chan'", "'const'", "'='", "'type'", "'var'", "':='", "'.'", "':'", "'++'", "'--'", "'if'", "'else'", "'switch'", "'case'", "'default'", "'for'", "'range'", "'go'", "'select'", "'return'", "'break'", "'continue'", "'goto'", "'fallthrough'", "'defer'", "'package'", "'import'"
    };
    public static final int T__68=68;
    public static final int T__69=69;
    public static final int T__66=66;
    public static final int Imaginary_lit=22;
    public static final int T__67=67;
    public static final int T__64=64;
    public static final int T__65=65;
    public static final int T__62=62;
    public static final int T__63=63;
    public static final int Byte_value=24;
    public static final int Exponent=20;
    public static final int Hex_digit=10;
    public static final int Octal_digit=9;
    public static final int Escaped_char=28;
    public static final int Assign_op=41;
    public static final int T__61=61;
    public static final int EOF=-1;
    public static final int T__60=60;
    public static final int Add_op=39;
    public static final int Identifier=14;
    public static final int Decimals=19;
    public static final int T__55=55;
    public static final int T__56=56;
    public static final int Unicode_value=23;
    public static final int T__57=57;
    public static final int T__58=58;
    public static final int T__51=51;
    public static final int T__52=52;
    public static final int T__53=53;
    public static final int T__54=54;
    public static final int Decimal_digit=8;
    public static final int T__59=59;
    public static final int Unicode_letter=5;
    public static final int Raw_string_lit=31;
    public static final int COMMENT=12;
    public static final int Little_u_value=26;
    public static final int T__50=50;
    public static final int Hex_byte_value=30;
    public static final int Unicode_digit=6;
    public static final int Log_op=36;
    public static final int T__42=42;
    public static final int T__43=43;
    public static final int Float_lit=21;
    public static final int T__46=46;
    public static final int T__80=80;
    public static final int T__47=47;
    public static final int T__81=81;
    public static final int T__82=82;
    public static final int T__44=44;
    public static final int Rel_op=38;
    public static final int T__45=45;
    public static final int LINE_COMMENT=11;
    public static final int Binary_op=34;
    public static final int T__48=48;
    public static final int T__49=49;
    public static final int Mul_op=40;
    public static final int Octal_byte_value=29;
    public static final int Interpreted_string_lit=32;
    public static final int Unicode_char=4;
    public static final int Com_op=37;
    public static final int Decimal_lit=15;
    public static final int Unary_op=35;
    public static final int Big_u_value=27;
    public static final int WS=13;
    public static final int T__71=71;
    public static final int T__72=72;
    public static final int T__70=70;
    public static final int String_lit=33;
    public static final int Octal_lit=16;
    public static final int Char_lit=25;
    public static final int Int_lit=18;
    public static final int Hex_lit=17;
    public static final int T__76=76;
    public static final int T__75=75;
    public static final int T__74=74;
    public static final int Letter=7;
    public static final int T__73=73;
    public static final int T__79=79;
    public static final int T__78=78;
    public static final int T__77=77;

    // delegates
    // delegators

    public static final String[] ruleNames = new String[] {
        "invalidRule", "synpred63_Go", "operand", "synpred24_Go", "labeledStmt", 
        "arrayType", "methodDecl", "synpred3_Go", "sendExpr", "synpred127_Go", 
        "qualifiedIdent", "topLevelDecl", "receiver", "typeName", "literalType", 
        "synpred117_Go", "synpred96_Go", "typeSwitchGuard", "synpred21_Go", 
        "fallthroughStmt", "synpred1_Go", "packageName", "arrayLength", 
        "literal", "synpred45_Go", "synpred62_Go", "methodExpr", "synpred73_Go", 
        "value", "synpred38_Go", "synpred49_Go", "synpred126_Go", "expressionList", 
        "slice", "synpred48_Go", "receiverType", "synpred83_Go", "synpred31_Go", 
        "synpred109_Go", "forClause", "result", "tag", "synpred46_Go", "switchStmt", 
        "label", "baseTypeName", "synpred8_Go", "synpred100_Go", "pointerType", 
        "synpred20_Go", "synpred137_Go", "parameters", "rangeClause", "synpred54_Go", 
        "synpred43_Go", "synpred122_Go", "synpred112_Go", "synpred69_Go", 
        "synpred11_Go", "synpred2_Go", "constDecl", "call", "synpred124_Go", 
        "synpred53_Go", "synpred18_Go", "synpred85_Go", "synpred36_Go", 
        "synpred70_Go", "mapType", "synpred97_Go", "synpred133_Go", "statement", 
        "compositeLit", "declaration", "basicLit", "channel", "synpred71_Go", 
        "selectStmt", "index", "importPath", "elementIndex", "key", "sendChannel", 
        "synpred26_Go", "recvChannel", "returnStmt", "typeAssertion", "synpred99_Go", 
        "builtinCall", "synpred68_Go", "interfaceType", "breakStmt", "sourceFile", 
        "synpred17_Go", "keyType", "synpred102_Go", "synpred12_Go", "parameterList", 
        "initStmt", "synpred79_Go", "synpred125_Go", "signature", "synpred110_Go", 
        "synpred50_Go", "assignment", "functionDecl", "body", "block", "synpred57_Go", 
        "synpred128_Go", "unaryExpr", "element", "recvExpr", "typeList", 
        "commCase", "synpred123_Go", "deferStmt", "synpred98_Go", "methodSpec", 
        "goStmt", "simpleStmt", "sliceType", "synpred33_Go", "synpred114_Go", 
        "synpred132_Go", "constSpec", "synpred64_Go", "exprSwitchStmt", 
        "synpred4_Go", "synpred80_Go", "synpred121_Go", "synpred108_Go", 
        "synpred28_Go", "synpred115_Go", "synpred136_Go", "elementList", 
        "functionLit", "synpred135_Go", "synpred82_Go", "synpred66_Go", 
        "synpred74_Go", "type", "synpred47_Go", "synpred59_Go", "synpred34_Go", 
        "typeLit", "commClause", "synpred7_Go", "synpred37_Go", "synpred138_Go", 
        "synpred78_Go", "synpred88_Go", "synpred93_Go", "synpred92_Go", 
        "synpred14_Go", "synpred61_Go", "synpred89_Go", "synpred94_Go", 
        "synpred76_Go", "incDecStmt", "synpred44_Go", "importDecl", "synpred6_Go", 
        "interfaceTypeName", "fieldDecl", "synpred35_Go", "synpred65_Go", 
        "synpred40_Go", "packageClause", "synpred75_Go", "synpred95_Go", 
        "typeDecl", "varDecl", "synpred120_Go", "synpred81_Go", "emptyStmt", 
        "synpred116_Go", "exprSwitchCase", "typeSwitchCase", "synpred131_Go", 
        "typeSwitchStmt", "expressionStmt", "gotoStmt", "synpred101_Go", 
        "synpred129_Go", "synpred113_Go", "synpred58_Go", "synpred32_Go", 
        "varSpec", "synpred27_Go", "synpred107_Go", "synpred39_Go", "synpred86_Go", 
        "continueStmt", "expression", "synpred91_Go", "synpred106_Go", "synpred29_Go", 
        "forStmt", "synpred105_Go", "typeCaseClause", "synpred23_Go", "methodName", 
        "synpred104_Go", "synpred90_Go", "baseType", "synpred13_Go", "synpred19_Go", 
        "elementType", "primaryExpr", "synpred16_Go", "condition", "ifStmt", 
        "synpred30_Go", "fieldName", "synpred134_Go", "synpred25_Go", "synpred67_Go", 
        "synpred15_Go", "synpred22_Go", "synpred119_Go", "functionType", 
        "synpred10_Go", "synpred103_Go", "synpred52_Go", "importSpec", "identifierList", 
        "selector", "synpred51_Go", "synpred55_Go", "postStmt", "structType", 
        "shortVarDecl", "parameterDecl", "conversion", "synpred56_Go", "synpred130_Go", 
        "synpred111_Go", "exprCaseClause", "channelType", "synpred41_Go", 
        "synpred60_Go", "synpred118_Go", "synpred139_Go", "synpred87_Go", 
        "synpred9_Go", "anonymousField", "builtinArgs", "synpred84_Go", 
        "synpred72_Go", "typeSpec", "synpred5_Go", "synpred42_Go", "synpred77_Go"
    };
     
        public int ruleLevel = 0;
        public int getRuleLevel() { return ruleLevel; }
        public void incRuleLevel() { ruleLevel++; }
        public void decRuleLevel() { ruleLevel--; }
        public GoParser(TokenStream input) {
            this(input, DebugEventSocketProxy.DEFAULT_DEBUGGER_PORT, new RecognizerSharedState());
        }
        public GoParser(TokenStream input, int port, RecognizerSharedState state) {
            super(input, state);
            this.state.ruleMemo = new HashMap[253+1];
             
            DebugEventSocketProxy proxy =
                new DebugEventSocketProxy(this, port, null);
            setDebugListener(proxy);
            try {
                proxy.handshake();
            }
            catch (IOException ioe) {
                reportError(ioe);
            }
        }
    public GoParser(TokenStream input, DebugEventListener dbg) {
        super(input, dbg, new RecognizerSharedState());
        this.state.ruleMemo = new HashMap[253+1];
         
    }
    protected boolean evalPredicate(boolean result, String predicate) {
        dbg.semanticPredicate(result, predicate);
        return result;
    }


    public String[] getTokenNames() { return GoParser.tokenNames; }
    public String getGrammarFileName() { return "/home/alex/Desktop/Go.g"; }



    // $ANTLR start "type"
    // /home/alex/Desktop/Go.g:159:1: type : ( typeName | typeLit | '(' type ')' );
    public final void type() throws RecognitionException {
        int type_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "type");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(159, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 1) ) { return ; }
            // /home/alex/Desktop/Go.g:160:2: ( typeName | typeLit | '(' type ')' )
            int alt1=3;
            try { dbg.enterDecision(1);

            switch ( input.LA(1) ) {
            case Identifier:
                {
                alt1=1;
                }
                break;
            case Com_op:
            case 44:
            case 46:
            case 50:
            case 51:
            case 54:
            case 55:
            case 56:
                {
                alt1=2;
                }
                break;
            case 42:
                {
                alt1=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 1, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }

            } finally {dbg.exitDecision(1);}

            switch (alt1) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:160:5: typeName
                    {
                    dbg.location(160,5);
                    pushFollow(FOLLOW_typeName_in_type1259);
                    typeName();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // /home/alex/Desktop/Go.g:160:16: typeLit
                    {
                    dbg.location(160,16);
                    pushFollow(FOLLOW_typeLit_in_type1263);
                    typeLit();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 3 :
                    dbg.enterAlt(3);

                    // /home/alex/Desktop/Go.g:160:26: '(' type ')'
                    {
                    dbg.location(160,26);
                    match(input,42,FOLLOW_42_in_type1267); if (state.failed) return ;
                    dbg.location(160,30);
                    pushFollow(FOLLOW_type_in_type1269);
                    type();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(160,35);
                    match(input,43,FOLLOW_43_in_type1271); if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 1, type_StartIndex); }
        }
        dbg.location(160, 39);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "type");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "type"


    // $ANTLR start "typeName"
    // /home/alex/Desktop/Go.g:161:1: typeName : qualifiedIdent ;
    public final void typeName() throws RecognitionException {
        int typeName_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "typeName");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(161, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 2) ) { return ; }
            // /home/alex/Desktop/Go.g:162:2: ( qualifiedIdent )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:162:5: qualifiedIdent
            {
            dbg.location(162,5);
            pushFollow(FOLLOW_qualifiedIdent_in_typeName1283);
            qualifiedIdent();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 2, typeName_StartIndex); }
        }
        dbg.location(162, 19);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "typeName");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "typeName"


    // $ANTLR start "typeLit"
    // /home/alex/Desktop/Go.g:163:1: typeLit : ( arrayType | structType | pointerType | functionType | interfaceType | sliceType | mapType | channelType );
    public final void typeLit() throws RecognitionException {
        int typeLit_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "typeLit");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(163, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 3) ) { return ; }
            // /home/alex/Desktop/Go.g:164:2: ( arrayType | structType | pointerType | functionType | interfaceType | sliceType | mapType | channelType )
            int alt2=8;
            try { dbg.enterDecision(2);

            try {
                isCyclicDecision = true;
                alt2 = dfa2.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(2);}

            switch (alt2) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:164:5: arrayType
                    {
                    dbg.location(164,5);
                    pushFollow(FOLLOW_arrayType_in_typeLit1295);
                    arrayType();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // /home/alex/Desktop/Go.g:164:17: structType
                    {
                    dbg.location(164,17);
                    pushFollow(FOLLOW_structType_in_typeLit1299);
                    structType();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 3 :
                    dbg.enterAlt(3);

                    // /home/alex/Desktop/Go.g:164:30: pointerType
                    {
                    dbg.location(164,30);
                    pushFollow(FOLLOW_pointerType_in_typeLit1303);
                    pointerType();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 4 :
                    dbg.enterAlt(4);

                    // /home/alex/Desktop/Go.g:164:44: functionType
                    {
                    dbg.location(164,44);
                    pushFollow(FOLLOW_functionType_in_typeLit1307);
                    functionType();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 5 :
                    dbg.enterAlt(5);

                    // /home/alex/Desktop/Go.g:164:59: interfaceType
                    {
                    dbg.location(164,59);
                    pushFollow(FOLLOW_interfaceType_in_typeLit1311);
                    interfaceType();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 6 :
                    dbg.enterAlt(6);

                    // /home/alex/Desktop/Go.g:165:6: sliceType
                    {
                    dbg.location(165,6);
                    pushFollow(FOLLOW_sliceType_in_typeLit1320);
                    sliceType();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 7 :
                    dbg.enterAlt(7);

                    // /home/alex/Desktop/Go.g:165:18: mapType
                    {
                    dbg.location(165,18);
                    pushFollow(FOLLOW_mapType_in_typeLit1324);
                    mapType();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 8 :
                    dbg.enterAlt(8);

                    // /home/alex/Desktop/Go.g:165:28: channelType
                    {
                    dbg.location(165,28);
                    pushFollow(FOLLOW_channelType_in_typeLit1328);
                    channelType();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 3, typeLit_StartIndex); }
        }
        dbg.location(165, 40);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "typeLit");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "typeLit"


    // $ANTLR start "arrayType"
    // /home/alex/Desktop/Go.g:167:1: arrayType : '[' arrayLength ']' elementType ;
    public final void arrayType() throws RecognitionException {
        int arrayType_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "arrayType");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(167, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 4) ) { return ; }
            // /home/alex/Desktop/Go.g:168:2: ( '[' arrayLength ']' elementType )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:168:5: '[' arrayLength ']' elementType
            {
            dbg.location(168,5);
            match(input,44,FOLLOW_44_in_arrayType1342); if (state.failed) return ;
            dbg.location(168,9);
            pushFollow(FOLLOW_arrayLength_in_arrayType1344);
            arrayLength();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(168,21);
            match(input,45,FOLLOW_45_in_arrayType1346); if (state.failed) return ;
            dbg.location(168,25);
            pushFollow(FOLLOW_elementType_in_arrayType1348);
            elementType();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 4, arrayType_StartIndex); }
        }
        dbg.location(168, 37);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "arrayType");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "arrayType"


    // $ANTLR start "arrayLength"
    // /home/alex/Desktop/Go.g:169:1: arrayLength : expression ;
    public final void arrayLength() throws RecognitionException {
        int arrayLength_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "arrayLength");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(169, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 5) ) { return ; }
            // /home/alex/Desktop/Go.g:170:2: ( expression )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:170:5: expression
            {
            dbg.location(170,5);
            pushFollow(FOLLOW_expression_in_arrayLength1359);
            expression();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 5, arrayLength_StartIndex); }
        }
        dbg.location(170, 16);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "arrayLength");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "arrayLength"


    // $ANTLR start "elementType"
    // /home/alex/Desktop/Go.g:171:1: elementType : type ;
    public final void elementType() throws RecognitionException {
        int elementType_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "elementType");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(171, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 6) ) { return ; }
            // /home/alex/Desktop/Go.g:172:2: ( type )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:172:5: type
            {
            dbg.location(172,5);
            pushFollow(FOLLOW_type_in_elementType1370);
            type();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 6, elementType_StartIndex); }
        }
        dbg.location(172, 10);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "elementType");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "elementType"


    // $ANTLR start "sliceType"
    // /home/alex/Desktop/Go.g:174:1: sliceType : '[' ']' elementType ;
    public final void sliceType() throws RecognitionException {
        int sliceType_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "sliceType");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(174, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 7) ) { return ; }
            // /home/alex/Desktop/Go.g:175:2: ( '[' ']' elementType )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:175:5: '[' ']' elementType
            {
            dbg.location(175,5);
            match(input,44,FOLLOW_44_in_sliceType1382); if (state.failed) return ;
            dbg.location(175,9);
            match(input,45,FOLLOW_45_in_sliceType1384); if (state.failed) return ;
            dbg.location(175,13);
            pushFollow(FOLLOW_elementType_in_sliceType1386);
            elementType();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 7, sliceType_StartIndex); }
        }
        dbg.location(175, 25);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "sliceType");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "sliceType"


    // $ANTLR start "structType"
    // /home/alex/Desktop/Go.g:177:1: structType : 'struct' '{' ( fieldDecl ';' )* '}' ;
    public final void structType() throws RecognitionException {
        int structType_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "structType");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(177, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 8) ) { return ; }
            // /home/alex/Desktop/Go.g:178:2: ( 'struct' '{' ( fieldDecl ';' )* '}' )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:178:5: 'struct' '{' ( fieldDecl ';' )* '}'
            {
            dbg.location(178,5);
            match(input,46,FOLLOW_46_in_structType1402); if (state.failed) return ;
            dbg.location(178,14);
            match(input,47,FOLLOW_47_in_structType1404); if (state.failed) return ;
            dbg.location(178,18);
            // /home/alex/Desktop/Go.g:178:18: ( fieldDecl ';' )*
            try { dbg.enterSubRule(3);

            loop3:
            do {
                int alt3=2;
                try { dbg.enterDecision(3);

                int LA3_0 = input.LA(1);

                if ( (LA3_0==Identifier||LA3_0==50) ) {
                    alt3=1;
                }


                } finally {dbg.exitDecision(3);}

                switch (alt3) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // /home/alex/Desktop/Go.g:178:20: fieldDecl ';'
            	    {
            	    dbg.location(178,20);
            	    pushFollow(FOLLOW_fieldDecl_in_structType1408);
            	    fieldDecl();

            	    state._fsp--;
            	    if (state.failed) return ;
            	    dbg.location(178,30);
            	    match(input,48,FOLLOW_48_in_structType1410); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop3;
                }
            } while (true);
            } finally {dbg.exitSubRule(3);}

            dbg.location(178,37);
            match(input,49,FOLLOW_49_in_structType1415); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 8, structType_StartIndex); }
        }
        dbg.location(178, 41);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "structType");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "structType"


    // $ANTLR start "fieldDecl"
    // /home/alex/Desktop/Go.g:179:1: fieldDecl : ( identifierList type | anonymousField ) ( tag )? ;
    public final void fieldDecl() throws RecognitionException {
        int fieldDecl_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "fieldDecl");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(179, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 9) ) { return ; }
            // /home/alex/Desktop/Go.g:180:2: ( ( identifierList type | anonymousField ) ( tag )? )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:180:5: ( identifierList type | anonymousField ) ( tag )?
            {
            dbg.location(180,5);
            // /home/alex/Desktop/Go.g:180:5: ( identifierList type | anonymousField )
            int alt4=2;
            try { dbg.enterSubRule(4);
            try { dbg.enterDecision(4);

            int LA4_0 = input.LA(1);

            if ( (LA4_0==Identifier) ) {
                int LA4_1 = input.LA(2);

                if ( (LA4_1==String_lit||LA4_1==48||LA4_1==62) ) {
                    alt4=2;
                }
                else if ( (LA4_1==Identifier||LA4_1==Com_op||LA4_1==42||LA4_1==44||LA4_1==46||(LA4_1>=50 && LA4_1<=52)||(LA4_1>=54 && LA4_1<=56)) ) {
                    alt4=1;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 4, 1, input);

                    dbg.recognitionException(nvae);
                    throw nvae;
                }
            }
            else if ( (LA4_0==50) ) {
                alt4=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 4, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(4);}

            switch (alt4) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:180:6: identifierList type
                    {
                    dbg.location(180,6);
                    pushFollow(FOLLOW_identifierList_in_fieldDecl1432);
                    identifierList();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(180,21);
                    pushFollow(FOLLOW_type_in_fieldDecl1434);
                    type();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // /home/alex/Desktop/Go.g:180:28: anonymousField
                    {
                    dbg.location(180,28);
                    pushFollow(FOLLOW_anonymousField_in_fieldDecl1438);
                    anonymousField();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(4);}

            dbg.location(180,44);
            // /home/alex/Desktop/Go.g:180:44: ( tag )?
            int alt5=2;
            try { dbg.enterSubRule(5);
            try { dbg.enterDecision(5);

            int LA5_0 = input.LA(1);

            if ( (LA5_0==String_lit) ) {
                alt5=1;
            }
            } finally {dbg.exitDecision(5);}

            switch (alt5) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:180:45: tag
                    {
                    dbg.location(180,45);
                    pushFollow(FOLLOW_tag_in_fieldDecl1442);
                    tag();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(5);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 9, fieldDecl_StartIndex); }
        }
        dbg.location(180, 51);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "fieldDecl");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "fieldDecl"


    // $ANTLR start "anonymousField"
    // /home/alex/Desktop/Go.g:181:1: anonymousField : ( '*' )? typeName ;
    public final void anonymousField() throws RecognitionException {
        int anonymousField_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "anonymousField");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(181, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 10) ) { return ; }
            // /home/alex/Desktop/Go.g:182:2: ( ( '*' )? typeName )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:182:5: ( '*' )? typeName
            {
            dbg.location(182,5);
            // /home/alex/Desktop/Go.g:182:5: ( '*' )?
            int alt6=2;
            try { dbg.enterSubRule(6);
            try { dbg.enterDecision(6);

            int LA6_0 = input.LA(1);

            if ( (LA6_0==50) ) {
                alt6=1;
            }
            } finally {dbg.exitDecision(6);}

            switch (alt6) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:182:6: '*'
                    {
                    dbg.location(182,6);
                    match(input,50,FOLLOW_50_in_anonymousField1456); if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(6);}

            dbg.location(182,12);
            pushFollow(FOLLOW_typeName_in_anonymousField1460);
            typeName();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 10, anonymousField_StartIndex); }
        }
        dbg.location(182, 21);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "anonymousField");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "anonymousField"


    // $ANTLR start "tag"
    // /home/alex/Desktop/Go.g:183:1: tag : String_lit ;
    public final void tag() throws RecognitionException {
        int tag_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "tag");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(183, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 11) ) { return ; }
            // /home/alex/Desktop/Go.g:184:2: ( String_lit )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:184:5: String_lit
            {
            dbg.location(184,5);
            match(input,String_lit,FOLLOW_String_lit_in_tag1482); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 11, tag_StartIndex); }
        }
        dbg.location(184, 16);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "tag");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "tag"


    // $ANTLR start "pointerType"
    // /home/alex/Desktop/Go.g:186:1: pointerType : '*' baseType ;
    public final void pointerType() throws RecognitionException {
        int pointerType_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "pointerType");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(186, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 12) ) { return ; }
            // /home/alex/Desktop/Go.g:187:2: ( '*' baseType )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:187:5: '*' baseType
            {
            dbg.location(187,5);
            match(input,50,FOLLOW_50_in_pointerType1494); if (state.failed) return ;
            dbg.location(187,9);
            pushFollow(FOLLOW_baseType_in_pointerType1496);
            baseType();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 12, pointerType_StartIndex); }
        }
        dbg.location(187, 18);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "pointerType");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "pointerType"


    // $ANTLR start "baseType"
    // /home/alex/Desktop/Go.g:188:1: baseType : type ;
    public final void baseType() throws RecognitionException {
        int baseType_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "baseType");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(188, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 13) ) { return ; }
            // /home/alex/Desktop/Go.g:189:2: ( type )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:189:5: type
            {
            dbg.location(189,5);
            pushFollow(FOLLOW_type_in_baseType1507);
            type();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 13, baseType_StartIndex); }
        }
        dbg.location(189, 10);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "baseType");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "baseType"


    // $ANTLR start "functionType"
    // /home/alex/Desktop/Go.g:191:1: functionType : 'func' signature ;
    public final void functionType() throws RecognitionException {
        int functionType_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "functionType");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(191, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 14) ) { return ; }
            // /home/alex/Desktop/Go.g:192:2: ( 'func' signature )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:192:5: 'func' signature
            {
            dbg.location(192,5);
            match(input,51,FOLLOW_51_in_functionType1521); if (state.failed) return ;
            dbg.location(192,12);
            pushFollow(FOLLOW_signature_in_functionType1523);
            signature();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 14, functionType_StartIndex); }
        }
        dbg.location(192, 22);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "functionType");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "functionType"


    // $ANTLR start "signature"
    // /home/alex/Desktop/Go.g:193:1: signature : parameters ( result )? ;
    public final void signature() throws RecognitionException {
        int signature_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "signature");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(193, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 15) ) { return ; }
            // /home/alex/Desktop/Go.g:194:2: ( parameters ( result )? )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:194:5: parameters ( result )?
            {
            dbg.location(194,5);
            pushFollow(FOLLOW_parameters_in_signature1539);
            parameters();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(194,16);
            // /home/alex/Desktop/Go.g:194:16: ( result )?
            int alt7=2;
            try { dbg.enterSubRule(7);
            try { dbg.enterDecision(7);

            try {
                isCyclicDecision = true;
                alt7 = dfa7.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(7);}

            switch (alt7) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:194:18: result
                    {
                    dbg.location(194,18);
                    pushFollow(FOLLOW_result_in_signature1543);
                    result();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(7);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 15, signature_StartIndex); }
        }
        dbg.location(194, 28);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "signature");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "signature"


    // $ANTLR start "result"
    // /home/alex/Desktop/Go.g:195:1: result : ( parameters | type );
    public final void result() throws RecognitionException {
        int result_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "result");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(195, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 16) ) { return ; }
            // /home/alex/Desktop/Go.g:196:2: ( parameters | type )
            int alt8=2;
            try { dbg.enterDecision(8);

            try {
                isCyclicDecision = true;
                alt8 = dfa8.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(8);}

            switch (alt8) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:196:5: parameters
                    {
                    dbg.location(196,5);
                    pushFollow(FOLLOW_parameters_in_result1565);
                    parameters();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // /home/alex/Desktop/Go.g:196:18: type
                    {
                    dbg.location(196,18);
                    pushFollow(FOLLOW_type_in_result1569);
                    type();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 16, result_StartIndex); }
        }
        dbg.location(196, 23);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "result");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "result"


    // $ANTLR start "parameters"
    // /home/alex/Desktop/Go.g:197:1: parameters : '(' ( parameterList ( ',' )? )? ')' ;
    public final void parameters() throws RecognitionException {
        int parameters_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "parameters");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(197, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 17) ) { return ; }
            // /home/alex/Desktop/Go.g:198:2: ( '(' ( parameterList ( ',' )? )? ')' )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:198:5: '(' ( parameterList ( ',' )? )? ')'
            {
            dbg.location(198,5);
            match(input,42,FOLLOW_42_in_parameters1584); if (state.failed) return ;
            dbg.location(198,9);
            // /home/alex/Desktop/Go.g:198:9: ( parameterList ( ',' )? )?
            int alt10=2;
            try { dbg.enterSubRule(10);
            try { dbg.enterDecision(10);

            int LA10_0 = input.LA(1);

            if ( (LA10_0==Identifier||LA10_0==Com_op||LA10_0==42||LA10_0==44||LA10_0==46||(LA10_0>=50 && LA10_0<=51)||(LA10_0>=53 && LA10_0<=56)) ) {
                alt10=1;
            }
            } finally {dbg.exitDecision(10);}

            switch (alt10) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:198:11: parameterList ( ',' )?
                    {
                    dbg.location(198,11);
                    pushFollow(FOLLOW_parameterList_in_parameters1588);
                    parameterList();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(198,25);
                    // /home/alex/Desktop/Go.g:198:25: ( ',' )?
                    int alt9=2;
                    try { dbg.enterSubRule(9);
                    try { dbg.enterDecision(9);

                    int LA9_0 = input.LA(1);

                    if ( (LA9_0==52) ) {
                        alt9=1;
                    }
                    } finally {dbg.exitDecision(9);}

                    switch (alt9) {
                        case 1 :
                            dbg.enterAlt(1);

                            // /home/alex/Desktop/Go.g:198:27: ','
                            {
                            dbg.location(198,27);
                            match(input,52,FOLLOW_52_in_parameters1592); if (state.failed) return ;

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(9);}


                    }
                    break;

            }
            } finally {dbg.exitSubRule(10);}

            dbg.location(198,37);
            match(input,43,FOLLOW_43_in_parameters1600); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 17, parameters_StartIndex); }
        }
        dbg.location(198, 41);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "parameters");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "parameters"


    // $ANTLR start "parameterList"
    // /home/alex/Desktop/Go.g:199:1: parameterList : parameterDecl ( ',' parameterDecl )* ;
    public final void parameterList() throws RecognitionException {
        int parameterList_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "parameterList");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(199, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 18) ) { return ; }
            // /home/alex/Desktop/Go.g:200:2: ( parameterDecl ( ',' parameterDecl )* )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:200:5: parameterDecl ( ',' parameterDecl )*
            {
            dbg.location(200,5);
            pushFollow(FOLLOW_parameterDecl_in_parameterList1612);
            parameterDecl();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(200,19);
            // /home/alex/Desktop/Go.g:200:19: ( ',' parameterDecl )*
            try { dbg.enterSubRule(11);

            loop11:
            do {
                int alt11=2;
                try { dbg.enterDecision(11);

                int LA11_0 = input.LA(1);

                if ( (LA11_0==52) ) {
                    int LA11_1 = input.LA(2);

                    if ( (LA11_1==Identifier||LA11_1==Com_op||LA11_1==42||LA11_1==44||LA11_1==46||(LA11_1>=50 && LA11_1<=51)||(LA11_1>=53 && LA11_1<=56)) ) {
                        alt11=1;
                    }


                }


                } finally {dbg.exitDecision(11);}

                switch (alt11) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // /home/alex/Desktop/Go.g:200:21: ',' parameterDecl
            	    {
            	    dbg.location(200,21);
            	    match(input,52,FOLLOW_52_in_parameterList1616); if (state.failed) return ;
            	    dbg.location(200,25);
            	    pushFollow(FOLLOW_parameterDecl_in_parameterList1618);
            	    parameterDecl();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop11;
                }
            } while (true);
            } finally {dbg.exitSubRule(11);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 18, parameterList_StartIndex); }
        }
        dbg.location(200, 42);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "parameterList");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "parameterList"


    // $ANTLR start "parameterDecl"
    // /home/alex/Desktop/Go.g:201:1: parameterDecl : ( identifierList )? ( type | '...' ( type )? ) ;
    public final void parameterDecl() throws RecognitionException {
        int parameterDecl_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "parameterDecl");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(201, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 19) ) { return ; }
            // /home/alex/Desktop/Go.g:202:2: ( ( identifierList )? ( type | '...' ( type )? ) )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:202:5: ( identifierList )? ( type | '...' ( type )? )
            {
            dbg.location(202,5);
            // /home/alex/Desktop/Go.g:202:5: ( identifierList )?
            int alt12=2;
            try { dbg.enterSubRule(12);
            try { dbg.enterDecision(12);

            int LA12_0 = input.LA(1);

            if ( (LA12_0==Identifier) ) {
                int LA12_1 = input.LA(2);

                if ( (LA12_1==52) ) {
                    int LA12_3 = input.LA(3);

                    if ( (LA12_3==Identifier) ) {
                        int LA12_5 = input.LA(4);

                        if ( (synpred19_Go()) ) {
                            alt12=1;
                        }
                    }
                }
                else if ( (LA12_1==Identifier||LA12_1==Com_op||LA12_1==42||LA12_1==44||LA12_1==46||(LA12_1>=50 && LA12_1<=51)||(LA12_1>=53 && LA12_1<=56)) ) {
                    alt12=1;
                }
            }
            } finally {dbg.exitDecision(12);}

            switch (alt12) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:202:7: identifierList
                    {
                    dbg.location(202,7);
                    pushFollow(FOLLOW_identifierList_in_parameterDecl1635);
                    identifierList();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(12);}

            dbg.location(202,25);
            // /home/alex/Desktop/Go.g:202:25: ( type | '...' ( type )? )
            int alt14=2;
            try { dbg.enterSubRule(14);
            try { dbg.enterDecision(14);

            int LA14_0 = input.LA(1);

            if ( (LA14_0==Identifier||LA14_0==Com_op||LA14_0==42||LA14_0==44||LA14_0==46||(LA14_0>=50 && LA14_0<=51)||(LA14_0>=54 && LA14_0<=56)) ) {
                alt14=1;
            }
            else if ( (LA14_0==53) ) {
                alt14=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 14, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(14);}

            switch (alt14) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:202:27: type
                    {
                    dbg.location(202,27);
                    pushFollow(FOLLOW_type_in_parameterDecl1642);
                    type();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // /home/alex/Desktop/Go.g:202:34: '...' ( type )?
                    {
                    dbg.location(202,34);
                    match(input,53,FOLLOW_53_in_parameterDecl1646); if (state.failed) return ;
                    dbg.location(202,40);
                    // /home/alex/Desktop/Go.g:202:40: ( type )?
                    int alt13=2;
                    try { dbg.enterSubRule(13);
                    try { dbg.enterDecision(13);

                    int LA13_0 = input.LA(1);

                    if ( (LA13_0==Identifier||LA13_0==Com_op||LA13_0==42||LA13_0==44||LA13_0==46||(LA13_0>=50 && LA13_0<=51)||(LA13_0>=54 && LA13_0<=56)) ) {
                        alt13=1;
                    }
                    } finally {dbg.exitDecision(13);}

                    switch (alt13) {
                        case 1 :
                            dbg.enterAlt(1);

                            // /home/alex/Desktop/Go.g:202:42: type
                            {
                            dbg.location(202,42);
                            pushFollow(FOLLOW_type_in_parameterDecl1650);
                            type();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(13);}


                    }
                    break;

            }
            } finally {dbg.exitSubRule(14);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 19, parameterDecl_StartIndex); }
        }
        dbg.location(202, 52);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "parameterDecl");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "parameterDecl"


    // $ANTLR start "interfaceType"
    // /home/alex/Desktop/Go.g:204:1: interfaceType : 'interface' '{' ( methodSpec ';' )* '}' ;
    public final void interfaceType() throws RecognitionException {
        int interfaceType_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "interfaceType");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(204, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 20) ) { return ; }
            // /home/alex/Desktop/Go.g:205:2: ( 'interface' '{' ( methodSpec ';' )* '}' )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:205:5: 'interface' '{' ( methodSpec ';' )* '}'
            {
            dbg.location(205,5);
            match(input,54,FOLLOW_54_in_interfaceType1672); if (state.failed) return ;
            dbg.location(205,17);
            match(input,47,FOLLOW_47_in_interfaceType1674); if (state.failed) return ;
            dbg.location(205,21);
            // /home/alex/Desktop/Go.g:205:21: ( methodSpec ';' )*
            try { dbg.enterSubRule(15);

            loop15:
            do {
                int alt15=2;
                try { dbg.enterDecision(15);

                int LA15_0 = input.LA(1);

                if ( (LA15_0==Identifier) ) {
                    alt15=1;
                }


                } finally {dbg.exitDecision(15);}

                switch (alt15) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // /home/alex/Desktop/Go.g:205:23: methodSpec ';'
            	    {
            	    dbg.location(205,23);
            	    pushFollow(FOLLOW_methodSpec_in_interfaceType1678);
            	    methodSpec();

            	    state._fsp--;
            	    if (state.failed) return ;
            	    dbg.location(205,34);
            	    match(input,48,FOLLOW_48_in_interfaceType1680); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop15;
                }
            } while (true);
            } finally {dbg.exitSubRule(15);}

            dbg.location(205,41);
            match(input,49,FOLLOW_49_in_interfaceType1685); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 20, interfaceType_StartIndex); }
        }
        dbg.location(205, 45);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "interfaceType");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "interfaceType"


    // $ANTLR start "methodSpec"
    // /home/alex/Desktop/Go.g:206:1: methodSpec : ( methodName signature | interfaceTypeName );
    public final void methodSpec() throws RecognitionException {
        int methodSpec_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "methodSpec");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(206, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 21) ) { return ; }
            // /home/alex/Desktop/Go.g:207:2: ( methodName signature | interfaceTypeName )
            int alt16=2;
            try { dbg.enterDecision(16);

            int LA16_0 = input.LA(1);

            if ( (LA16_0==Identifier) ) {
                int LA16_1 = input.LA(2);

                if ( (LA16_1==48||LA16_1==62) ) {
                    alt16=2;
                }
                else if ( (LA16_1==42) ) {
                    alt16=1;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 16, 1, input);

                    dbg.recognitionException(nvae);
                    throw nvae;
                }
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 16, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(16);}

            switch (alt16) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:207:5: methodName signature
                    {
                    dbg.location(207,5);
                    pushFollow(FOLLOW_methodName_in_methodSpec1704);
                    methodName();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(207,16);
                    pushFollow(FOLLOW_signature_in_methodSpec1706);
                    signature();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // /home/alex/Desktop/Go.g:207:28: interfaceTypeName
                    {
                    dbg.location(207,28);
                    pushFollow(FOLLOW_interfaceTypeName_in_methodSpec1710);
                    interfaceTypeName();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 21, methodSpec_StartIndex); }
        }
        dbg.location(207, 46);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "methodSpec");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "methodSpec"


    // $ANTLR start "methodName"
    // /home/alex/Desktop/Go.g:208:1: methodName : Identifier ;
    public final void methodName() throws RecognitionException {
        int methodName_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "methodName");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(208, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 22) ) { return ; }
            // /home/alex/Desktop/Go.g:209:2: ( Identifier )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:209:5: Identifier
            {
            dbg.location(209,5);
            match(input,Identifier,FOLLOW_Identifier_in_methodName1729); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 22, methodName_StartIndex); }
        }
        dbg.location(209, 16);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "methodName");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "methodName"


    // $ANTLR start "interfaceTypeName"
    // /home/alex/Desktop/Go.g:210:1: interfaceTypeName : typeName ;
    public final void interfaceTypeName() throws RecognitionException {
        int interfaceTypeName_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "interfaceTypeName");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(210, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 23) ) { return ; }
            // /home/alex/Desktop/Go.g:211:2: ( typeName )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:211:5: typeName
            {
            dbg.location(211,5);
            pushFollow(FOLLOW_typeName_in_interfaceTypeName1741);
            typeName();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 23, interfaceTypeName_StartIndex); }
        }
        dbg.location(211, 14);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "interfaceTypeName");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "interfaceTypeName"


    // $ANTLR start "mapType"
    // /home/alex/Desktop/Go.g:213:1: mapType : 'map' '[' keyType ']' elementType ;
    public final void mapType() throws RecognitionException {
        int mapType_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "mapType");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(213, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 24) ) { return ; }
            // /home/alex/Desktop/Go.g:214:2: ( 'map' '[' keyType ']' elementType )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:214:5: 'map' '[' keyType ']' elementType
            {
            dbg.location(214,5);
            match(input,55,FOLLOW_55_in_mapType1757); if (state.failed) return ;
            dbg.location(214,11);
            match(input,44,FOLLOW_44_in_mapType1759); if (state.failed) return ;
            dbg.location(214,15);
            pushFollow(FOLLOW_keyType_in_mapType1761);
            keyType();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(214,23);
            match(input,45,FOLLOW_45_in_mapType1763); if (state.failed) return ;
            dbg.location(214,27);
            pushFollow(FOLLOW_elementType_in_mapType1765);
            elementType();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 24, mapType_StartIndex); }
        }
        dbg.location(214, 39);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "mapType");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "mapType"


    // $ANTLR start "keyType"
    // /home/alex/Desktop/Go.g:215:1: keyType : type ;
    public final void keyType() throws RecognitionException {
        int keyType_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "keyType");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(215, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 25) ) { return ; }
            // /home/alex/Desktop/Go.g:216:2: ( type )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:216:5: type
            {
            dbg.location(216,5);
            pushFollow(FOLLOW_type_in_keyType1780);
            type();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 25, keyType_StartIndex); }
        }
        dbg.location(216, 10);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "keyType");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "keyType"


    // $ANTLR start "channelType"
    // /home/alex/Desktop/Go.g:218:1: channelType : ( channel | sendChannel | recvChannel );
    public final void channelType() throws RecognitionException {
        int channelType_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "channelType");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(218, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 26) ) { return ; }
            // /home/alex/Desktop/Go.g:219:2: ( channel | sendChannel | recvChannel )
            int alt17=3;
            try { dbg.enterDecision(17);

            int LA17_0 = input.LA(1);

            if ( (LA17_0==56) ) {
                int LA17_1 = input.LA(2);

                if ( (synpred24_Go()) ) {
                    alt17=1;
                }
                else if ( (synpred25_Go()) ) {
                    alt17=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 17, 1, input);

                    dbg.recognitionException(nvae);
                    throw nvae;
                }
            }
            else if ( (LA17_0==Com_op) ) {
                alt17=3;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 17, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(17);}

            switch (alt17) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:219:5: channel
                    {
                    dbg.location(219,5);
                    pushFollow(FOLLOW_channel_in_channelType1794);
                    channel();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // /home/alex/Desktop/Go.g:219:15: sendChannel
                    {
                    dbg.location(219,15);
                    pushFollow(FOLLOW_sendChannel_in_channelType1798);
                    sendChannel();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 3 :
                    dbg.enterAlt(3);

                    // /home/alex/Desktop/Go.g:219:29: recvChannel
                    {
                    dbg.location(219,29);
                    pushFollow(FOLLOW_recvChannel_in_channelType1802);
                    recvChannel();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 26, channelType_StartIndex); }
        }
        dbg.location(219, 41);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "channelType");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "channelType"


    // $ANTLR start "channel"
    // /home/alex/Desktop/Go.g:220:1: channel : 'chan' elementType ;
    public final void channel() throws RecognitionException {
        int channel_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "channel");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(220, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 27) ) { return ; }
            // /home/alex/Desktop/Go.g:221:2: ( 'chan' elementType )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:221:5: 'chan' elementType
            {
            dbg.location(221,5);
            match(input,56,FOLLOW_56_in_channel1819); if (state.failed) return ;
            dbg.location(221,12);
            pushFollow(FOLLOW_elementType_in_channel1821);
            elementType();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 27, channel_StartIndex); }
        }
        dbg.location(221, 24);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "channel");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "channel"


    // $ANTLR start "sendChannel"
    // /home/alex/Desktop/Go.g:222:1: sendChannel : 'chan' '<-' elementType ;
    public final void sendChannel() throws RecognitionException {
        int sendChannel_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "sendChannel");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(222, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 28) ) { return ; }
            // /home/alex/Desktop/Go.g:223:2: ( 'chan' '<-' elementType )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:223:5: 'chan' '<-' elementType
            {
            dbg.location(223,5);
            match(input,56,FOLLOW_56_in_sendChannel1834); if (state.failed) return ;
            dbg.location(223,12);
            match(input,Com_op,FOLLOW_Com_op_in_sendChannel1836); if (state.failed) return ;
            dbg.location(223,17);
            pushFollow(FOLLOW_elementType_in_sendChannel1838);
            elementType();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 28, sendChannel_StartIndex); }
        }
        dbg.location(223, 29);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "sendChannel");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "sendChannel"


    // $ANTLR start "recvChannel"
    // /home/alex/Desktop/Go.g:224:1: recvChannel : '<-' 'chan' elementType ;
    public final void recvChannel() throws RecognitionException {
        int recvChannel_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "recvChannel");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(224, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 29) ) { return ; }
            // /home/alex/Desktop/Go.g:225:2: ( '<-' 'chan' elementType )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:225:5: '<-' 'chan' elementType
            {
            dbg.location(225,5);
            match(input,Com_op,FOLLOW_Com_op_in_recvChannel1851); if (state.failed) return ;
            dbg.location(225,10);
            match(input,56,FOLLOW_56_in_recvChannel1853); if (state.failed) return ;
            dbg.location(225,17);
            pushFollow(FOLLOW_elementType_in_recvChannel1855);
            elementType();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 29, recvChannel_StartIndex); }
        }
        dbg.location(225, 29);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "recvChannel");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "recvChannel"


    // $ANTLR start "block"
    // /home/alex/Desktop/Go.g:227:1: block : '{' ( statement ';' )* '}' ;
    public final void block() throws RecognitionException {
        int block_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "block");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(227, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 30) ) { return ; }
            // /home/alex/Desktop/Go.g:227:8: ( '{' ( statement ';' )* '}' )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:227:11: '{' ( statement ';' )* '}'
            {
            dbg.location(227,11);
            match(input,47,FOLLOW_47_in_block1866); if (state.failed) return ;
            dbg.location(227,15);
            // /home/alex/Desktop/Go.g:227:15: ( statement ';' )*
            try { dbg.enterSubRule(18);

            loop18:
            do {
                int alt18=2;
                try { dbg.enterDecision(18);

                int LA18_0 = input.LA(1);

                if ( (LA18_0==EOF||LA18_0==Identifier||LA18_0==Int_lit||(LA18_0>=Float_lit && LA18_0<=Imaginary_lit)||LA18_0==Char_lit||LA18_0==String_lit||LA18_0==Unary_op||LA18_0==42||LA18_0==44||(LA18_0>=46 && LA18_0<=48)||LA18_0==51||LA18_0==55||LA18_0==57||(LA18_0>=59 && LA18_0<=60)||LA18_0==66||LA18_0==68||LA18_0==71||(LA18_0>=73 && LA18_0<=80)) ) {
                    alt18=1;
                }


                } finally {dbg.exitDecision(18);}

                switch (alt18) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // /home/alex/Desktop/Go.g:227:17: statement ';'
            	    {
            	    dbg.location(227,17);
            	    pushFollow(FOLLOW_statement_in_block1870);
            	    statement();

            	    state._fsp--;
            	    if (state.failed) return ;
            	    dbg.location(227,27);
            	    match(input,48,FOLLOW_48_in_block1872); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop18;
                }
            } while (true);
            } finally {dbg.exitSubRule(18);}

            dbg.location(227,34);
            match(input,49,FOLLOW_49_in_block1877); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 30, block_StartIndex); }
        }
        dbg.location(227, 38);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "block");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "block"


    // $ANTLR start "declaration"
    // /home/alex/Desktop/Go.g:229:1: declaration : ( constDecl | typeDecl | varDecl );
    public final void declaration() throws RecognitionException {
        int declaration_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "declaration");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(229, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 31) ) { return ; }
            // /home/alex/Desktop/Go.g:230:2: ( constDecl | typeDecl | varDecl )
            int alt19=3;
            try { dbg.enterDecision(19);

            switch ( input.LA(1) ) {
            case 57:
                {
                alt19=1;
                }
                break;
            case 59:
                {
                alt19=2;
                }
                break;
            case 60:
                {
                alt19=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 19, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }

            } finally {dbg.exitDecision(19);}

            switch (alt19) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:230:5: constDecl
                    {
                    dbg.location(230,5);
                    pushFollow(FOLLOW_constDecl_in_declaration1891);
                    constDecl();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // /home/alex/Desktop/Go.g:230:17: typeDecl
                    {
                    dbg.location(230,17);
                    pushFollow(FOLLOW_typeDecl_in_declaration1895);
                    typeDecl();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 3 :
                    dbg.enterAlt(3);

                    // /home/alex/Desktop/Go.g:230:28: varDecl
                    {
                    dbg.location(230,28);
                    pushFollow(FOLLOW_varDecl_in_declaration1899);
                    varDecl();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 31, declaration_StartIndex); }
        }
        dbg.location(230, 36);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "declaration");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "declaration"


    // $ANTLR start "topLevelDecl"
    // /home/alex/Desktop/Go.g:231:1: topLevelDecl : ( declaration | functionDecl | methodDecl );
    public final void topLevelDecl() throws RecognitionException {
        int topLevelDecl_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "topLevelDecl");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(231, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 32) ) { return ; }
            // /home/alex/Desktop/Go.g:232:2: ( declaration | functionDecl | methodDecl )
            int alt20=3;
            try { dbg.enterDecision(20);

            int LA20_0 = input.LA(1);

            if ( (LA20_0==57||(LA20_0>=59 && LA20_0<=60)) ) {
                alt20=1;
            }
            else if ( (LA20_0==51) ) {
                int LA20_2 = input.LA(2);

                if ( (LA20_2==Identifier) ) {
                    alt20=2;
                }
                else if ( (LA20_2==42) ) {
                    alt20=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 20, 2, input);

                    dbg.recognitionException(nvae);
                    throw nvae;
                }
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 20, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(20);}

            switch (alt20) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:232:5: declaration
                    {
                    dbg.location(232,5);
                    pushFollow(FOLLOW_declaration_in_topLevelDecl1911);
                    declaration();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // /home/alex/Desktop/Go.g:232:19: functionDecl
                    {
                    dbg.location(232,19);
                    pushFollow(FOLLOW_functionDecl_in_topLevelDecl1915);
                    functionDecl();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 3 :
                    dbg.enterAlt(3);

                    // /home/alex/Desktop/Go.g:232:34: methodDecl
                    {
                    dbg.location(232,34);
                    pushFollow(FOLLOW_methodDecl_in_topLevelDecl1919);
                    methodDecl();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 32, topLevelDecl_StartIndex); }
        }
        dbg.location(232, 45);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "topLevelDecl");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "topLevelDecl"


    // $ANTLR start "constDecl"
    // /home/alex/Desktop/Go.g:234:1: constDecl : 'const' ( constSpec | '(' ( constSpec ';' )* ')' ) ;
    public final void constDecl() throws RecognitionException {
        int constDecl_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "constDecl");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(234, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 33) ) { return ; }
            // /home/alex/Desktop/Go.g:235:2: ( 'const' ( constSpec | '(' ( constSpec ';' )* ')' ) )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:235:5: 'const' ( constSpec | '(' ( constSpec ';' )* ')' )
            {
            dbg.location(235,5);
            match(input,57,FOLLOW_57_in_constDecl1936); if (state.failed) return ;
            dbg.location(235,13);
            // /home/alex/Desktop/Go.g:235:13: ( constSpec | '(' ( constSpec ';' )* ')' )
            int alt22=2;
            try { dbg.enterSubRule(22);
            try { dbg.enterDecision(22);

            int LA22_0 = input.LA(1);

            if ( (LA22_0==Identifier) ) {
                alt22=1;
            }
            else if ( (LA22_0==42) ) {
                alt22=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 22, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(22);}

            switch (alt22) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:235:15: constSpec
                    {
                    dbg.location(235,15);
                    pushFollow(FOLLOW_constSpec_in_constDecl1940);
                    constSpec();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // /home/alex/Desktop/Go.g:235:27: '(' ( constSpec ';' )* ')'
                    {
                    dbg.location(235,27);
                    match(input,42,FOLLOW_42_in_constDecl1944); if (state.failed) return ;
                    dbg.location(235,31);
                    // /home/alex/Desktop/Go.g:235:31: ( constSpec ';' )*
                    try { dbg.enterSubRule(21);

                    loop21:
                    do {
                        int alt21=2;
                        try { dbg.enterDecision(21);

                        int LA21_0 = input.LA(1);

                        if ( (LA21_0==Identifier) ) {
                            alt21=1;
                        }


                        } finally {dbg.exitDecision(21);}

                        switch (alt21) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // /home/alex/Desktop/Go.g:235:33: constSpec ';'
                    	    {
                    	    dbg.location(235,33);
                    	    pushFollow(FOLLOW_constSpec_in_constDecl1948);
                    	    constSpec();

                    	    state._fsp--;
                    	    if (state.failed) return ;
                    	    dbg.location(235,43);
                    	    match(input,48,FOLLOW_48_in_constDecl1950); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop21;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(21);}

                    dbg.location(235,50);
                    match(input,43,FOLLOW_43_in_constDecl1955); if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(22);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 33, constDecl_StartIndex); }
        }
        dbg.location(235, 56);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "constDecl");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "constDecl"


    // $ANTLR start "constSpec"
    // /home/alex/Desktop/Go.g:236:1: constSpec : identifierList ( ( type )? '=' expressionList )? ;
    public final void constSpec() throws RecognitionException {
        int constSpec_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "constSpec");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(236, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 34) ) { return ; }
            // /home/alex/Desktop/Go.g:237:2: ( identifierList ( ( type )? '=' expressionList )? )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:237:5: identifierList ( ( type )? '=' expressionList )?
            {
            dbg.location(237,5);
            pushFollow(FOLLOW_identifierList_in_constSpec1973);
            identifierList();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(237,20);
            // /home/alex/Desktop/Go.g:237:20: ( ( type )? '=' expressionList )?
            int alt24=2;
            try { dbg.enterSubRule(24);
            try { dbg.enterDecision(24);

            int LA24_0 = input.LA(1);

            if ( (LA24_0==Identifier||LA24_0==Com_op||LA24_0==42||LA24_0==44||LA24_0==46||(LA24_0>=50 && LA24_0<=51)||(LA24_0>=54 && LA24_0<=56)||LA24_0==58) ) {
                alt24=1;
            }
            } finally {dbg.exitDecision(24);}

            switch (alt24) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:237:22: ( type )? '=' expressionList
                    {
                    dbg.location(237,22);
                    // /home/alex/Desktop/Go.g:237:22: ( type )?
                    int alt23=2;
                    try { dbg.enterSubRule(23);
                    try { dbg.enterDecision(23);

                    int LA23_0 = input.LA(1);

                    if ( (LA23_0==Identifier||LA23_0==Com_op||LA23_0==42||LA23_0==44||LA23_0==46||(LA23_0>=50 && LA23_0<=51)||(LA23_0>=54 && LA23_0<=56)) ) {
                        alt23=1;
                    }
                    } finally {dbg.exitDecision(23);}

                    switch (alt23) {
                        case 1 :
                            dbg.enterAlt(1);

                            // /home/alex/Desktop/Go.g:237:24: type
                            {
                            dbg.location(237,24);
                            pushFollow(FOLLOW_type_in_constSpec1979);
                            type();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(23);}

                    dbg.location(237,32);
                    match(input,58,FOLLOW_58_in_constSpec1984); if (state.failed) return ;
                    dbg.location(237,36);
                    pushFollow(FOLLOW_expressionList_in_constSpec1986);
                    expressionList();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(24);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 34, constSpec_StartIndex); }
        }
        dbg.location(237, 54);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "constSpec");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "constSpec"


    // $ANTLR start "identifierList"
    // /home/alex/Desktop/Go.g:239:1: identifierList : Identifier ( ',' Identifier )* ;
    public final void identifierList() throws RecognitionException {
        int identifierList_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "identifierList");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(239, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 35) ) { return ; }
            // /home/alex/Desktop/Go.g:240:2: ( Identifier ( ',' Identifier )* )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:240:5: Identifier ( ',' Identifier )*
            {
            dbg.location(240,5);
            match(input,Identifier,FOLLOW_Identifier_in_identifierList2002); if (state.failed) return ;
            dbg.location(240,16);
            // /home/alex/Desktop/Go.g:240:16: ( ',' Identifier )*
            try { dbg.enterSubRule(25);

            loop25:
            do {
                int alt25=2;
                try { dbg.enterDecision(25);

                int LA25_0 = input.LA(1);

                if ( (LA25_0==52) ) {
                    alt25=1;
                }


                } finally {dbg.exitDecision(25);}

                switch (alt25) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // /home/alex/Desktop/Go.g:240:18: ',' Identifier
            	    {
            	    dbg.location(240,18);
            	    match(input,52,FOLLOW_52_in_identifierList2006); if (state.failed) return ;
            	    dbg.location(240,22);
            	    match(input,Identifier,FOLLOW_Identifier_in_identifierList2008); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop25;
                }
            } while (true);
            } finally {dbg.exitSubRule(25);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 35, identifierList_StartIndex); }
        }
        dbg.location(240, 36);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "identifierList");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "identifierList"


    // $ANTLR start "expressionList"
    // /home/alex/Desktop/Go.g:241:1: expressionList : expression ( ',' expression )* ;
    public final void expressionList() throws RecognitionException {
        int expressionList_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "expressionList");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(241, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 36) ) { return ; }
            // /home/alex/Desktop/Go.g:242:2: ( expression ( ',' expression )* )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:242:5: expression ( ',' expression )*
            {
            dbg.location(242,5);
            pushFollow(FOLLOW_expression_in_expressionList2022);
            expression();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(242,16);
            // /home/alex/Desktop/Go.g:242:16: ( ',' expression )*
            try { dbg.enterSubRule(26);

            loop26:
            do {
                int alt26=2;
                try { dbg.enterDecision(26);

                int LA26_0 = input.LA(1);

                if ( (LA26_0==52) ) {
                    int LA26_2 = input.LA(2);

                    if ( (LA26_2==Identifier||LA26_2==Int_lit||(LA26_2>=Float_lit && LA26_2<=Imaginary_lit)||LA26_2==Char_lit||LA26_2==String_lit||LA26_2==Unary_op||LA26_2==42||LA26_2==44||LA26_2==46||LA26_2==51||LA26_2==55) ) {
                        alt26=1;
                    }


                }


                } finally {dbg.exitDecision(26);}

                switch (alt26) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // /home/alex/Desktop/Go.g:242:18: ',' expression
            	    {
            	    dbg.location(242,18);
            	    match(input,52,FOLLOW_52_in_expressionList2026); if (state.failed) return ;
            	    dbg.location(242,22);
            	    pushFollow(FOLLOW_expression_in_expressionList2028);
            	    expression();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop26;
                }
            } while (true);
            } finally {dbg.exitSubRule(26);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 36, expressionList_StartIndex); }
        }
        dbg.location(242, 36);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "expressionList");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "expressionList"


    // $ANTLR start "typeDecl"
    // /home/alex/Desktop/Go.g:244:1: typeDecl : 'type' ( typeSpec | '(' ( typeSpec ';' )* ')' ) ;
    public final void typeDecl() throws RecognitionException {
        int typeDecl_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "typeDecl");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(244, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 37) ) { return ; }
            // /home/alex/Desktop/Go.g:245:2: ( 'type' ( typeSpec | '(' ( typeSpec ';' )* ')' ) )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:245:5: 'type' ( typeSpec | '(' ( typeSpec ';' )* ')' )
            {
            dbg.location(245,5);
            match(input,59,FOLLOW_59_in_typeDecl2047); if (state.failed) return ;
            dbg.location(245,12);
            // /home/alex/Desktop/Go.g:245:12: ( typeSpec | '(' ( typeSpec ';' )* ')' )
            int alt28=2;
            try { dbg.enterSubRule(28);
            try { dbg.enterDecision(28);

            int LA28_0 = input.LA(1);

            if ( (LA28_0==Identifier) ) {
                alt28=1;
            }
            else if ( (LA28_0==42) ) {
                alt28=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 28, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(28);}

            switch (alt28) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:245:14: typeSpec
                    {
                    dbg.location(245,14);
                    pushFollow(FOLLOW_typeSpec_in_typeDecl2051);
                    typeSpec();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // /home/alex/Desktop/Go.g:245:25: '(' ( typeSpec ';' )* ')'
                    {
                    dbg.location(245,25);
                    match(input,42,FOLLOW_42_in_typeDecl2055); if (state.failed) return ;
                    dbg.location(245,29);
                    // /home/alex/Desktop/Go.g:245:29: ( typeSpec ';' )*
                    try { dbg.enterSubRule(27);

                    loop27:
                    do {
                        int alt27=2;
                        try { dbg.enterDecision(27);

                        int LA27_0 = input.LA(1);

                        if ( (LA27_0==Identifier) ) {
                            alt27=1;
                        }


                        } finally {dbg.exitDecision(27);}

                        switch (alt27) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // /home/alex/Desktop/Go.g:245:31: typeSpec ';'
                    	    {
                    	    dbg.location(245,31);
                    	    pushFollow(FOLLOW_typeSpec_in_typeDecl2059);
                    	    typeSpec();

                    	    state._fsp--;
                    	    if (state.failed) return ;
                    	    dbg.location(245,40);
                    	    match(input,48,FOLLOW_48_in_typeDecl2061); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop27;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(27);}

                    dbg.location(245,47);
                    match(input,43,FOLLOW_43_in_typeDecl2066); if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(28);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 37, typeDecl_StartIndex); }
        }
        dbg.location(245, 53);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "typeDecl");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "typeDecl"


    // $ANTLR start "typeSpec"
    // /home/alex/Desktop/Go.g:246:1: typeSpec : Identifier type ;
    public final void typeSpec() throws RecognitionException {
        int typeSpec_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "typeSpec");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(246, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 38) ) { return ; }
            // /home/alex/Desktop/Go.g:247:2: ( Identifier type )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:247:5: Identifier type
            {
            dbg.location(247,5);
            match(input,Identifier,FOLLOW_Identifier_in_typeSpec2083); if (state.failed) return ;
            dbg.location(247,16);
            pushFollow(FOLLOW_type_in_typeSpec2085);
            type();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 38, typeSpec_StartIndex); }
        }
        dbg.location(247, 21);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "typeSpec");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "typeSpec"


    // $ANTLR start "varDecl"
    // /home/alex/Desktop/Go.g:249:1: varDecl : 'var' ( varSpec | '(' ( varSpec ';' )* ')' ) ;
    public final void varDecl() throws RecognitionException {
        int varDecl_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "varDecl");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(249, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 39) ) { return ; }
            // /home/alex/Desktop/Go.g:250:2: ( 'var' ( varSpec | '(' ( varSpec ';' )* ')' ) )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:250:5: 'var' ( varSpec | '(' ( varSpec ';' )* ')' )
            {
            dbg.location(250,5);
            match(input,60,FOLLOW_60_in_varDecl2101); if (state.failed) return ;
            dbg.location(250,11);
            // /home/alex/Desktop/Go.g:250:11: ( varSpec | '(' ( varSpec ';' )* ')' )
            int alt30=2;
            try { dbg.enterSubRule(30);
            try { dbg.enterDecision(30);

            int LA30_0 = input.LA(1);

            if ( (LA30_0==Identifier) ) {
                alt30=1;
            }
            else if ( (LA30_0==42) ) {
                alt30=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 30, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(30);}

            switch (alt30) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:250:13: varSpec
                    {
                    dbg.location(250,13);
                    pushFollow(FOLLOW_varSpec_in_varDecl2105);
                    varSpec();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // /home/alex/Desktop/Go.g:250:23: '(' ( varSpec ';' )* ')'
                    {
                    dbg.location(250,23);
                    match(input,42,FOLLOW_42_in_varDecl2109); if (state.failed) return ;
                    dbg.location(250,27);
                    // /home/alex/Desktop/Go.g:250:27: ( varSpec ';' )*
                    try { dbg.enterSubRule(29);

                    loop29:
                    do {
                        int alt29=2;
                        try { dbg.enterDecision(29);

                        int LA29_0 = input.LA(1);

                        if ( (LA29_0==Identifier) ) {
                            alt29=1;
                        }


                        } finally {dbg.exitDecision(29);}

                        switch (alt29) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // /home/alex/Desktop/Go.g:250:29: varSpec ';'
                    	    {
                    	    dbg.location(250,29);
                    	    pushFollow(FOLLOW_varSpec_in_varDecl2113);
                    	    varSpec();

                    	    state._fsp--;
                    	    if (state.failed) return ;
                    	    dbg.location(250,37);
                    	    match(input,48,FOLLOW_48_in_varDecl2115); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop29;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(29);}

                    dbg.location(250,44);
                    match(input,43,FOLLOW_43_in_varDecl2120); if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(30);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 39, varDecl_StartIndex); }
        }
        dbg.location(250, 50);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "varDecl");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "varDecl"


    // $ANTLR start "varSpec"
    // /home/alex/Desktop/Go.g:251:1: varSpec : identifierList ( type ( '=' expressionList )? | '=' expressionList ) ;
    public final void varSpec() throws RecognitionException {
        int varSpec_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "varSpec");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(251, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 40) ) { return ; }
            // /home/alex/Desktop/Go.g:252:2: ( identifierList ( type ( '=' expressionList )? | '=' expressionList ) )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:252:5: identifierList ( type ( '=' expressionList )? | '=' expressionList )
            {
            dbg.location(252,5);
            pushFollow(FOLLOW_identifierList_in_varSpec2137);
            identifierList();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(252,20);
            // /home/alex/Desktop/Go.g:252:20: ( type ( '=' expressionList )? | '=' expressionList )
            int alt32=2;
            try { dbg.enterSubRule(32);
            try { dbg.enterDecision(32);

            int LA32_0 = input.LA(1);

            if ( (LA32_0==Identifier||LA32_0==Com_op||LA32_0==42||LA32_0==44||LA32_0==46||(LA32_0>=50 && LA32_0<=51)||(LA32_0>=54 && LA32_0<=56)) ) {
                alt32=1;
            }
            else if ( (LA32_0==58) ) {
                alt32=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 32, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(32);}

            switch (alt32) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:252:22: type ( '=' expressionList )?
                    {
                    dbg.location(252,22);
                    pushFollow(FOLLOW_type_in_varSpec2141);
                    type();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(252,27);
                    // /home/alex/Desktop/Go.g:252:27: ( '=' expressionList )?
                    int alt31=2;
                    try { dbg.enterSubRule(31);
                    try { dbg.enterDecision(31);

                    int LA31_0 = input.LA(1);

                    if ( (LA31_0==58) ) {
                        alt31=1;
                    }
                    } finally {dbg.exitDecision(31);}

                    switch (alt31) {
                        case 1 :
                            dbg.enterAlt(1);

                            // /home/alex/Desktop/Go.g:252:29: '=' expressionList
                            {
                            dbg.location(252,29);
                            match(input,58,FOLLOW_58_in_varSpec2145); if (state.failed) return ;
                            dbg.location(252,33);
                            pushFollow(FOLLOW_expressionList_in_varSpec2147);
                            expressionList();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(31);}


                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // /home/alex/Desktop/Go.g:252:53: '=' expressionList
                    {
                    dbg.location(252,53);
                    match(input,58,FOLLOW_58_in_varSpec2154); if (state.failed) return ;
                    dbg.location(252,57);
                    pushFollow(FOLLOW_expressionList_in_varSpec2156);
                    expressionList();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(32);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 40, varSpec_StartIndex); }
        }
        dbg.location(252, 74);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "varSpec");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "varSpec"


    // $ANTLR start "shortVarDecl"
    // /home/alex/Desktop/Go.g:254:1: shortVarDecl : identifierList ':=' expressionList ;
    public final void shortVarDecl() throws RecognitionException {
        int shortVarDecl_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "shortVarDecl");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(254, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 41) ) { return ; }
            // /home/alex/Desktop/Go.g:255:2: ( identifierList ':=' expressionList )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:255:5: identifierList ':=' expressionList
            {
            dbg.location(255,5);
            pushFollow(FOLLOW_identifierList_in_shortVarDecl2170);
            identifierList();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(255,20);
            match(input,61,FOLLOW_61_in_shortVarDecl2172); if (state.failed) return ;
            dbg.location(255,25);
            pushFollow(FOLLOW_expressionList_in_shortVarDecl2174);
            expressionList();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 41, shortVarDecl_StartIndex); }
        }
        dbg.location(255, 40);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "shortVarDecl");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "shortVarDecl"


    // $ANTLR start "functionDecl"
    // /home/alex/Desktop/Go.g:257:1: functionDecl : 'func' Identifier signature ( body )? ;
    public final void functionDecl() throws RecognitionException {
        int functionDecl_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "functionDecl");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(257, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 42) ) { return ; }
            // /home/alex/Desktop/Go.g:258:2: ( 'func' Identifier signature ( body )? )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:258:5: 'func' Identifier signature ( body )?
            {
            dbg.location(258,5);
            match(input,51,FOLLOW_51_in_functionDecl2186); if (state.failed) return ;
            dbg.location(258,12);
            match(input,Identifier,FOLLOW_Identifier_in_functionDecl2188); if (state.failed) return ;
            dbg.location(258,23);
            pushFollow(FOLLOW_signature_in_functionDecl2190);
            signature();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(258,33);
            // /home/alex/Desktop/Go.g:258:33: ( body )?
            int alt33=2;
            try { dbg.enterSubRule(33);
            try { dbg.enterDecision(33);

            int LA33_0 = input.LA(1);

            if ( (LA33_0==47) ) {
                alt33=1;
            }
            } finally {dbg.exitDecision(33);}

            switch (alt33) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:258:35: body
                    {
                    dbg.location(258,35);
                    pushFollow(FOLLOW_body_in_functionDecl2194);
                    body();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(33);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 42, functionDecl_StartIndex); }
        }
        dbg.location(258, 43);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "functionDecl");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "functionDecl"


    // $ANTLR start "body"
    // /home/alex/Desktop/Go.g:259:1: body : block ;
    public final void body() throws RecognitionException {
        int body_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "body");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(259, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 43) ) { return ; }
            // /home/alex/Desktop/Go.g:260:2: ( block )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:260:5: block
            {
            dbg.location(260,5);
            pushFollow(FOLLOW_block_in_body2216);
            block();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 43, body_StartIndex); }
        }
        dbg.location(260, 10);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "body");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "body"


    // $ANTLR start "methodDecl"
    // /home/alex/Desktop/Go.g:262:1: methodDecl : 'func' receiver methodName signature ( body )? ;
    public final void methodDecl() throws RecognitionException {
        int methodDecl_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "methodDecl");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(262, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 44) ) { return ; }
            // /home/alex/Desktop/Go.g:263:2: ( 'func' receiver methodName signature ( body )? )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:263:5: 'func' receiver methodName signature ( body )?
            {
            dbg.location(263,5);
            match(input,51,FOLLOW_51_in_methodDecl2229); if (state.failed) return ;
            dbg.location(263,12);
            pushFollow(FOLLOW_receiver_in_methodDecl2231);
            receiver();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(263,21);
            pushFollow(FOLLOW_methodName_in_methodDecl2233);
            methodName();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(263,32);
            pushFollow(FOLLOW_signature_in_methodDecl2235);
            signature();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(263,42);
            // /home/alex/Desktop/Go.g:263:42: ( body )?
            int alt34=2;
            try { dbg.enterSubRule(34);
            try { dbg.enterDecision(34);

            int LA34_0 = input.LA(1);

            if ( (LA34_0==47) ) {
                alt34=1;
            }
            } finally {dbg.exitDecision(34);}

            switch (alt34) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:263:44: body
                    {
                    dbg.location(263,44);
                    pushFollow(FOLLOW_body_in_methodDecl2239);
                    body();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(34);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 44, methodDecl_StartIndex); }
        }
        dbg.location(263, 52);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "methodDecl");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "methodDecl"


    // $ANTLR start "receiver"
    // /home/alex/Desktop/Go.g:264:1: receiver : '(' ( Identifier )? ( '*' )? baseTypeName ')' ;
    public final void receiver() throws RecognitionException {
        int receiver_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "receiver");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(264, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 45) ) { return ; }
            // /home/alex/Desktop/Go.g:265:2: ( '(' ( Identifier )? ( '*' )? baseTypeName ')' )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:265:5: '(' ( Identifier )? ( '*' )? baseTypeName ')'
            {
            dbg.location(265,5);
            match(input,42,FOLLOW_42_in_receiver2257); if (state.failed) return ;
            dbg.location(265,9);
            // /home/alex/Desktop/Go.g:265:9: ( Identifier )?
            int alt35=2;
            try { dbg.enterSubRule(35);
            try { dbg.enterDecision(35);

            int LA35_0 = input.LA(1);

            if ( (LA35_0==Identifier) ) {
                int LA35_1 = input.LA(2);

                if ( (LA35_1==Identifier||LA35_1==50) ) {
                    alt35=1;
                }
            }
            } finally {dbg.exitDecision(35);}

            switch (alt35) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:265:11: Identifier
                    {
                    dbg.location(265,11);
                    match(input,Identifier,FOLLOW_Identifier_in_receiver2261); if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(35);}

            dbg.location(265,25);
            // /home/alex/Desktop/Go.g:265:25: ( '*' )?
            int alt36=2;
            try { dbg.enterSubRule(36);
            try { dbg.enterDecision(36);

            int LA36_0 = input.LA(1);

            if ( (LA36_0==50) ) {
                alt36=1;
            }
            } finally {dbg.exitDecision(36);}

            switch (alt36) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:265:27: '*'
                    {
                    dbg.location(265,27);
                    match(input,50,FOLLOW_50_in_receiver2268); if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(36);}

            dbg.location(265,34);
            pushFollow(FOLLOW_baseTypeName_in_receiver2273);
            baseTypeName();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(265,47);
            match(input,43,FOLLOW_43_in_receiver2275); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 45, receiver_StartIndex); }
        }
        dbg.location(265, 51);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "receiver");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "receiver"


    // $ANTLR start "baseTypeName"
    // /home/alex/Desktop/Go.g:266:1: baseTypeName : Identifier ;
    public final void baseTypeName() throws RecognitionException {
        int baseTypeName_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "baseTypeName");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(266, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 46) ) { return ; }
            // /home/alex/Desktop/Go.g:267:2: ( Identifier )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:267:5: Identifier
            {
            dbg.location(267,5);
            match(input,Identifier,FOLLOW_Identifier_in_baseTypeName2286); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 46, baseTypeName_StartIndex); }
        }
        dbg.location(267, 16);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "baseTypeName");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "baseTypeName"


    // $ANTLR start "operand"
    // /home/alex/Desktop/Go.g:269:1: operand : ( literal | qualifiedIdent | methodExpr | '(' expression ')' );
    public final void operand() throws RecognitionException {
        int operand_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "operand");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(269, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 47) ) { return ; }
            // /home/alex/Desktop/Go.g:270:2: ( literal | qualifiedIdent | methodExpr | '(' expression ')' )
            int alt37=4;
            try { dbg.enterDecision(37);

            try {
                isCyclicDecision = true;
                alt37 = dfa37.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(37);}

            switch (alt37) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:270:5: literal
                    {
                    dbg.location(270,5);
                    pushFollow(FOLLOW_literal_in_operand2300);
                    literal();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // /home/alex/Desktop/Go.g:270:15: qualifiedIdent
                    {
                    dbg.location(270,15);
                    pushFollow(FOLLOW_qualifiedIdent_in_operand2304);
                    qualifiedIdent();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 3 :
                    dbg.enterAlt(3);

                    // /home/alex/Desktop/Go.g:270:32: methodExpr
                    {
                    dbg.location(270,32);
                    pushFollow(FOLLOW_methodExpr_in_operand2308);
                    methodExpr();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 4 :
                    dbg.enterAlt(4);

                    // /home/alex/Desktop/Go.g:270:45: '(' expression ')'
                    {
                    dbg.location(270,45);
                    match(input,42,FOLLOW_42_in_operand2312); if (state.failed) return ;
                    dbg.location(270,49);
                    pushFollow(FOLLOW_expression_in_operand2314);
                    expression();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(270,60);
                    match(input,43,FOLLOW_43_in_operand2316); if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 47, operand_StartIndex); }
        }
        dbg.location(270, 64);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "operand");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "operand"


    // $ANTLR start "literal"
    // /home/alex/Desktop/Go.g:271:1: literal : ( basicLit | compositeLit | functionLit );
    public final void literal() throws RecognitionException {
        int literal_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "literal");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(271, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 48) ) { return ; }
            // /home/alex/Desktop/Go.g:272:2: ( basicLit | compositeLit | functionLit )
            int alt38=3;
            try { dbg.enterDecision(38);

            switch ( input.LA(1) ) {
            case Int_lit:
            case Float_lit:
            case Imaginary_lit:
            case Char_lit:
            case String_lit:
                {
                alt38=1;
                }
                break;
            case Identifier:
            case 42:
            case 44:
            case 46:
            case 55:
                {
                alt38=2;
                }
                break;
            case 51:
                {
                alt38=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 38, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }

            } finally {dbg.exitDecision(38);}

            switch (alt38) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:272:5: basicLit
                    {
                    dbg.location(272,5);
                    pushFollow(FOLLOW_basicLit_in_literal2330);
                    basicLit();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // /home/alex/Desktop/Go.g:272:16: compositeLit
                    {
                    dbg.location(272,16);
                    pushFollow(FOLLOW_compositeLit_in_literal2334);
                    compositeLit();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 3 :
                    dbg.enterAlt(3);

                    // /home/alex/Desktop/Go.g:272:31: functionLit
                    {
                    dbg.location(272,31);
                    pushFollow(FOLLOW_functionLit_in_literal2338);
                    functionLit();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 48, literal_StartIndex); }
        }
        dbg.location(272, 43);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "literal");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "literal"


    // $ANTLR start "basicLit"
    // /home/alex/Desktop/Go.g:273:1: basicLit : ( Int_lit | Float_lit | Imaginary_lit | Char_lit | String_lit );
    public final void basicLit() throws RecognitionException {
        int basicLit_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "basicLit");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(273, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 49) ) { return ; }
            // /home/alex/Desktop/Go.g:274:2: ( Int_lit | Float_lit | Imaginary_lit | Char_lit | String_lit )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:
            {
            dbg.location(274,2);
            if ( input.LA(1)==Int_lit||(input.LA(1)>=Float_lit && input.LA(1)<=Imaginary_lit)||input.LA(1)==Char_lit||input.LA(1)==String_lit ) {
                input.consume();
                state.errorRecovery=false;state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                dbg.recognitionException(mse);
                throw mse;
            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 49, basicLit_StartIndex); }
        }
        dbg.location(274, 65);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "basicLit");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "basicLit"


    // $ANTLR start "qualifiedIdent"
    // /home/alex/Desktop/Go.g:276:1: qualifiedIdent : ( packageName '.' )? Identifier ;
    public final void qualifiedIdent() throws RecognitionException {
        int qualifiedIdent_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "qualifiedIdent");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(276, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 50) ) { return ; }
            // /home/alex/Desktop/Go.g:277:2: ( ( packageName '.' )? Identifier )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:277:5: ( packageName '.' )? Identifier
            {
            dbg.location(277,5);
            // /home/alex/Desktop/Go.g:277:5: ( packageName '.' )?
            int alt39=2;
            try { dbg.enterSubRule(39);
            try { dbg.enterDecision(39);

            int LA39_0 = input.LA(1);

            if ( (LA39_0==Identifier) ) {
                int LA39_1 = input.LA(2);

                if ( (LA39_1==62) ) {
                    int LA39_3 = input.LA(3);

                    if ( (LA39_3==Identifier) ) {
                        int LA39_4 = input.LA(4);

                        if ( (synpred56_Go()) ) {
                            alt39=1;
                        }
                    }
                }
            }
            } finally {dbg.exitDecision(39);}

            switch (alt39) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:277:7: packageName '.'
                    {
                    dbg.location(277,7);
                    pushFollow(FOLLOW_packageName_in_qualifiedIdent2381);
                    packageName();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(277,19);
                    match(input,62,FOLLOW_62_in_qualifiedIdent2383); if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(39);}

            dbg.location(277,26);
            match(input,Identifier,FOLLOW_Identifier_in_qualifiedIdent2388); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 50, qualifiedIdent_StartIndex); }
        }
        dbg.location(277, 37);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "qualifiedIdent");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "qualifiedIdent"


    // $ANTLR start "compositeLit"
    // /home/alex/Desktop/Go.g:279:1: compositeLit : literalType '{' ( elementList ( ',' )? )? '}' ;
    public final void compositeLit() throws RecognitionException {
        int compositeLit_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "compositeLit");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(279, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 51) ) { return ; }
            // /home/alex/Desktop/Go.g:280:2: ( literalType '{' ( elementList ( ',' )? )? '}' )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:280:5: literalType '{' ( elementList ( ',' )? )? '}'
            {
            dbg.location(280,5);
            pushFollow(FOLLOW_literalType_in_compositeLit2401);
            literalType();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(280,17);
            match(input,47,FOLLOW_47_in_compositeLit2403); if (state.failed) return ;
            dbg.location(280,21);
            // /home/alex/Desktop/Go.g:280:21: ( elementList ( ',' )? )?
            int alt41=2;
            try { dbg.enterSubRule(41);
            try { dbg.enterDecision(41);

            int LA41_0 = input.LA(1);

            if ( (LA41_0==Identifier||LA41_0==Int_lit||(LA41_0>=Float_lit && LA41_0<=Imaginary_lit)||LA41_0==Char_lit||LA41_0==String_lit||LA41_0==Unary_op||LA41_0==42||LA41_0==44||LA41_0==46||LA41_0==51||LA41_0==55) ) {
                alt41=1;
            }
            } finally {dbg.exitDecision(41);}

            switch (alt41) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:280:23: elementList ( ',' )?
                    {
                    dbg.location(280,23);
                    pushFollow(FOLLOW_elementList_in_compositeLit2407);
                    elementList();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(280,35);
                    // /home/alex/Desktop/Go.g:280:35: ( ',' )?
                    int alt40=2;
                    try { dbg.enterSubRule(40);
                    try { dbg.enterDecision(40);

                    int LA40_0 = input.LA(1);

                    if ( (LA40_0==52) ) {
                        alt40=1;
                    }
                    } finally {dbg.exitDecision(40);}

                    switch (alt40) {
                        case 1 :
                            dbg.enterAlt(1);

                            // /home/alex/Desktop/Go.g:280:37: ','
                            {
                            dbg.location(280,37);
                            match(input,52,FOLLOW_52_in_compositeLit2411); if (state.failed) return ;

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(40);}


                    }
                    break;

            }
            } finally {dbg.exitSubRule(41);}

            dbg.location(280,47);
            match(input,49,FOLLOW_49_in_compositeLit2419); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 51, compositeLit_StartIndex); }
        }
        dbg.location(280, 51);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "compositeLit");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "compositeLit"


    // $ANTLR start "literalType"
    // /home/alex/Desktop/Go.g:281:1: literalType : ( structType | arrayType | '[' '...' ']' elementType | sliceType | mapType | typeName | '(' literalType ')' );
    public final void literalType() throws RecognitionException {
        int literalType_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "literalType");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(281, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 52) ) { return ; }
            // /home/alex/Desktop/Go.g:282:2: ( structType | arrayType | '[' '...' ']' elementType | sliceType | mapType | typeName | '(' literalType ')' )
            int alt42=7;
            try { dbg.enterDecision(42);

            switch ( input.LA(1) ) {
            case 46:
                {
                alt42=1;
                }
                break;
            case 44:
                {
                switch ( input.LA(2) ) {
                case 53:
                    {
                    alt42=3;
                    }
                    break;
                case 45:
                    {
                    alt42=4;
                    }
                    break;
                case Identifier:
                case Int_lit:
                case Float_lit:
                case Imaginary_lit:
                case Char_lit:
                case String_lit:
                case Unary_op:
                case 42:
                case 44:
                case 46:
                case 51:
                case 55:
                    {
                    alt42=2;
                    }
                    break;
                default:
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 42, 2, input);

                    dbg.recognitionException(nvae);
                    throw nvae;
                }

                }
                break;
            case 55:
                {
                alt42=5;
                }
                break;
            case Identifier:
                {
                alt42=6;
                }
                break;
            case 42:
                {
                alt42=7;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 42, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }

            } finally {dbg.exitDecision(42);}

            switch (alt42) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:282:5: structType
                    {
                    dbg.location(282,5);
                    pushFollow(FOLLOW_structType_in_literalType2432);
                    structType();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // /home/alex/Desktop/Go.g:282:18: arrayType
                    {
                    dbg.location(282,18);
                    pushFollow(FOLLOW_arrayType_in_literalType2436);
                    arrayType();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 3 :
                    dbg.enterAlt(3);

                    // /home/alex/Desktop/Go.g:282:30: '[' '...' ']' elementType
                    {
                    dbg.location(282,30);
                    match(input,44,FOLLOW_44_in_literalType2440); if (state.failed) return ;
                    dbg.location(282,34);
                    match(input,53,FOLLOW_53_in_literalType2442); if (state.failed) return ;
                    dbg.location(282,40);
                    match(input,45,FOLLOW_45_in_literalType2444); if (state.failed) return ;
                    dbg.location(282,44);
                    pushFollow(FOLLOW_elementType_in_literalType2446);
                    elementType();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 4 :
                    dbg.enterAlt(4);

                    // /home/alex/Desktop/Go.g:283:17: sliceType
                    {
                    dbg.location(283,17);
                    pushFollow(FOLLOW_sliceType_in_literalType2466);
                    sliceType();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 5 :
                    dbg.enterAlt(5);

                    // /home/alex/Desktop/Go.g:283:29: mapType
                    {
                    dbg.location(283,29);
                    pushFollow(FOLLOW_mapType_in_literalType2470);
                    mapType();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 6 :
                    dbg.enterAlt(6);

                    // /home/alex/Desktop/Go.g:283:39: typeName
                    {
                    dbg.location(283,39);
                    pushFollow(FOLLOW_typeName_in_literalType2474);
                    typeName();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 7 :
                    dbg.enterAlt(7);

                    // /home/alex/Desktop/Go.g:283:50: '(' literalType ')'
                    {
                    dbg.location(283,50);
                    match(input,42,FOLLOW_42_in_literalType2478); if (state.failed) return ;
                    dbg.location(283,54);
                    pushFollow(FOLLOW_literalType_in_literalType2480);
                    literalType();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(283,66);
                    match(input,43,FOLLOW_43_in_literalType2482); if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 52, literalType_StartIndex); }
        }
        dbg.location(283, 70);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "literalType");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "literalType"


    // $ANTLR start "elementList"
    // /home/alex/Desktop/Go.g:284:1: elementList : element ( ',' element )* ;
    public final void elementList() throws RecognitionException {
        int elementList_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "elementList");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(284, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 53) ) { return ; }
            // /home/alex/Desktop/Go.g:285:2: ( element ( ',' element )* )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:285:5: element ( ',' element )*
            {
            dbg.location(285,5);
            pushFollow(FOLLOW_element_in_elementList2495);
            element();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(285,13);
            // /home/alex/Desktop/Go.g:285:13: ( ',' element )*
            try { dbg.enterSubRule(43);

            loop43:
            do {
                int alt43=2;
                try { dbg.enterDecision(43);

                int LA43_0 = input.LA(1);

                if ( (LA43_0==52) ) {
                    int LA43_1 = input.LA(2);

                    if ( (LA43_1==Identifier||LA43_1==Int_lit||(LA43_1>=Float_lit && LA43_1<=Imaginary_lit)||LA43_1==Char_lit||LA43_1==String_lit||LA43_1==Unary_op||LA43_1==42||LA43_1==44||LA43_1==46||LA43_1==51||LA43_1==55) ) {
                        alt43=1;
                    }


                }


                } finally {dbg.exitDecision(43);}

                switch (alt43) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // /home/alex/Desktop/Go.g:285:15: ',' element
            	    {
            	    dbg.location(285,15);
            	    match(input,52,FOLLOW_52_in_elementList2499); if (state.failed) return ;
            	    dbg.location(285,19);
            	    pushFollow(FOLLOW_element_in_elementList2501);
            	    element();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop43;
                }
            } while (true);
            } finally {dbg.exitSubRule(43);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 53, elementList_StartIndex); }
        }
        dbg.location(285, 30);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "elementList");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "elementList"


    // $ANTLR start "element"
    // /home/alex/Desktop/Go.g:286:1: element : ( key ':' )? value ;
    public final void element() throws RecognitionException {
        int element_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "element");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(286, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 54) ) { return ; }
            // /home/alex/Desktop/Go.g:287:2: ( ( key ':' )? value )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:287:5: ( key ':' )? value
            {
            dbg.location(287,5);
            // /home/alex/Desktop/Go.g:287:5: ( key ':' )?
            int alt44=2;
            try { dbg.enterSubRule(44);
            try { dbg.enterDecision(44);

            try {
                isCyclicDecision = true;
                alt44 = dfa44.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(44);}

            switch (alt44) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:287:7: key ':'
                    {
                    dbg.location(287,7);
                    pushFollow(FOLLOW_key_in_element2523);
                    key();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(287,11);
                    match(input,63,FOLLOW_63_in_element2525); if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(44);}

            dbg.location(287,18);
            pushFollow(FOLLOW_value_in_element2530);
            value();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 54, element_StartIndex); }
        }
        dbg.location(287, 24);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "element");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "element"


    // $ANTLR start "key"
    // /home/alex/Desktop/Go.g:288:1: key : ( fieldName | elementIndex );
    public final void key() throws RecognitionException {
        int key_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "key");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(288, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 55) ) { return ; }
            // /home/alex/Desktop/Go.g:289:2: ( fieldName | elementIndex )
            int alt45=2;
            try { dbg.enterDecision(45);

            int LA45_0 = input.LA(1);

            if ( (LA45_0==Identifier) ) {
                int LA45_1 = input.LA(2);

                if ( (synpred67_Go()) ) {
                    alt45=1;
                }
                else if ( (true) ) {
                    alt45=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 45, 1, input);

                    dbg.recognitionException(nvae);
                    throw nvae;
                }
            }
            else if ( (LA45_0==Int_lit||(LA45_0>=Float_lit && LA45_0<=Imaginary_lit)||LA45_0==Char_lit||LA45_0==String_lit||LA45_0==Unary_op||LA45_0==42||LA45_0==44||LA45_0==46||LA45_0==51||LA45_0==55) ) {
                alt45=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 45, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(45);}

            switch (alt45) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:289:5: fieldName
                    {
                    dbg.location(289,5);
                    pushFollow(FOLLOW_fieldName_in_key2551);
                    fieldName();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // /home/alex/Desktop/Go.g:289:17: elementIndex
                    {
                    dbg.location(289,17);
                    pushFollow(FOLLOW_elementIndex_in_key2555);
                    elementIndex();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 55, key_StartIndex); }
        }
        dbg.location(289, 30);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "key");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "key"


    // $ANTLR start "fieldName"
    // /home/alex/Desktop/Go.g:290:1: fieldName : Identifier ;
    public final void fieldName() throws RecognitionException {
        int fieldName_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "fieldName");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(290, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 56) ) { return ; }
            // /home/alex/Desktop/Go.g:291:2: ( Identifier )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:291:5: Identifier
            {
            dbg.location(291,5);
            match(input,Identifier,FOLLOW_Identifier_in_fieldName2570); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 56, fieldName_StartIndex); }
        }
        dbg.location(291, 16);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "fieldName");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "fieldName"


    // $ANTLR start "elementIndex"
    // /home/alex/Desktop/Go.g:292:1: elementIndex : expression ;
    public final void elementIndex() throws RecognitionException {
        int elementIndex_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "elementIndex");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(292, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 57) ) { return ; }
            // /home/alex/Desktop/Go.g:293:2: ( expression )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:293:5: expression
            {
            dbg.location(293,5);
            pushFollow(FOLLOW_expression_in_elementIndex2582);
            expression();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 57, elementIndex_StartIndex); }
        }
        dbg.location(293, 16);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "elementIndex");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "elementIndex"


    // $ANTLR start "value"
    // /home/alex/Desktop/Go.g:294:1: value : expression ;
    public final void value() throws RecognitionException {
        int value_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "value");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(294, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 58) ) { return ; }
            // /home/alex/Desktop/Go.g:295:2: ( expression )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:295:5: expression
            {
            dbg.location(295,5);
            pushFollow(FOLLOW_expression_in_value2601);
            expression();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 58, value_StartIndex); }
        }
        dbg.location(295, 16);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "value");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "value"


    // $ANTLR start "functionLit"
    // /home/alex/Desktop/Go.g:297:1: functionLit : functionType body ;
    public final void functionLit() throws RecognitionException {
        int functionLit_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "functionLit");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(297, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 59) ) { return ; }
            // /home/alex/Desktop/Go.g:298:2: ( functionType body )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:298:5: functionType body
            {
            dbg.location(298,5);
            pushFollow(FOLLOW_functionType_in_functionLit2613);
            functionType();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(298,18);
            pushFollow(FOLLOW_body_in_functionLit2615);
            body();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 59, functionLit_StartIndex); }
        }
        dbg.location(298, 23);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "functionLit");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "functionLit"


    // $ANTLR start "primaryExpr"
    // /home/alex/Desktop/Go.g:301:1: primaryExpr : ( operand | conversion | builtinCall ) ( selector | index | slice | typeAssertion | call )* ;
    public final void primaryExpr() throws RecognitionException {
        int primaryExpr_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "primaryExpr");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(301, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 60) ) { return ; }
            // /home/alex/Desktop/Go.g:302:2: ( ( operand | conversion | builtinCall ) ( selector | index | slice | typeAssertion | call )* )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:303:2: ( operand | conversion | builtinCall ) ( selector | index | slice | typeAssertion | call )*
            {
            dbg.location(303,2);
            // /home/alex/Desktop/Go.g:303:2: ( operand | conversion | builtinCall )
            int alt46=3;
            try { dbg.enterSubRule(46);
            try { dbg.enterDecision(46);

            try {
                isCyclicDecision = true;
                alt46 = dfa46.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(46);}

            switch (alt46) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:303:3: operand
                    {
                    dbg.location(303,3);
                    pushFollow(FOLLOW_operand_in_primaryExpr2630);
                    operand();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // /home/alex/Desktop/Go.g:303:13: conversion
                    {
                    dbg.location(303,13);
                    pushFollow(FOLLOW_conversion_in_primaryExpr2634);
                    conversion();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 3 :
                    dbg.enterAlt(3);

                    // /home/alex/Desktop/Go.g:303:26: builtinCall
                    {
                    dbg.location(303,26);
                    pushFollow(FOLLOW_builtinCall_in_primaryExpr2638);
                    builtinCall();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(46);}

            dbg.location(303,39);
            // /home/alex/Desktop/Go.g:303:39: ( selector | index | slice | typeAssertion | call )*
            try { dbg.enterSubRule(47);

            loop47:
            do {
                int alt47=6;
                try { dbg.enterDecision(47);

                try {
                    isCyclicDecision = true;
                    alt47 = dfa47.predict(input);
                }
                catch (NoViableAltException nvae) {
                    dbg.recognitionException(nvae);
                    throw nvae;
                }
                } finally {dbg.exitDecision(47);}

                switch (alt47) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // /home/alex/Desktop/Go.g:303:40: selector
            	    {
            	    dbg.location(303,40);
            	    pushFollow(FOLLOW_selector_in_primaryExpr2642);
            	    selector();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;
            	case 2 :
            	    dbg.enterAlt(2);

            	    // /home/alex/Desktop/Go.g:303:51: index
            	    {
            	    dbg.location(303,51);
            	    pushFollow(FOLLOW_index_in_primaryExpr2646);
            	    index();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;
            	case 3 :
            	    dbg.enterAlt(3);

            	    // /home/alex/Desktop/Go.g:303:59: slice
            	    {
            	    dbg.location(303,59);
            	    pushFollow(FOLLOW_slice_in_primaryExpr2650);
            	    slice();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;
            	case 4 :
            	    dbg.enterAlt(4);

            	    // /home/alex/Desktop/Go.g:303:67: typeAssertion
            	    {
            	    dbg.location(303,67);
            	    pushFollow(FOLLOW_typeAssertion_in_primaryExpr2654);
            	    typeAssertion();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;
            	case 5 :
            	    dbg.enterAlt(5);

            	    // /home/alex/Desktop/Go.g:303:83: call
            	    {
            	    dbg.location(303,83);
            	    pushFollow(FOLLOW_call_in_primaryExpr2658);
            	    call();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop47;
                }
            } while (true);
            } finally {dbg.exitSubRule(47);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 60, primaryExpr_StartIndex); }
        }
        dbg.location(303, 90);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "primaryExpr");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "primaryExpr"


    // $ANTLR start "selector"
    // /home/alex/Desktop/Go.g:305:1: selector : '.' Identifier ;
    public final void selector() throws RecognitionException {
        int selector_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "selector");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(305, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 61) ) { return ; }
            // /home/alex/Desktop/Go.g:306:2: ( '.' Identifier )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:306:5: '.' Identifier
            {
            dbg.location(306,5);
            match(input,62,FOLLOW_62_in_selector2678); if (state.failed) return ;
            dbg.location(306,9);
            match(input,Identifier,FOLLOW_Identifier_in_selector2680); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 61, selector_StartIndex); }
        }
        dbg.location(306, 20);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "selector");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "selector"


    // $ANTLR start "index"
    // /home/alex/Desktop/Go.g:307:1: index : '[' expression ']' ;
    public final void index() throws RecognitionException {
        int index_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "index");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(307, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 62) ) { return ; }
            // /home/alex/Desktop/Go.g:308:2: ( '[' expression ']' )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:308:5: '[' expression ']'
            {
            dbg.location(308,5);
            match(input,44,FOLLOW_44_in_index2700); if (state.failed) return ;
            dbg.location(308,9);
            pushFollow(FOLLOW_expression_in_index2702);
            expression();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(308,20);
            match(input,45,FOLLOW_45_in_index2704); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 62, index_StartIndex); }
        }
        dbg.location(308, 24);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "index");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "index"


    // $ANTLR start "slice"
    // /home/alex/Desktop/Go.g:309:1: slice : '[' expression ':' ( expression )? ']' ;
    public final void slice() throws RecognitionException {
        int slice_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "slice");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(309, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 63) ) { return ; }
            // /home/alex/Desktop/Go.g:310:2: ( '[' expression ':' ( expression )? ']' )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:310:5: '[' expression ':' ( expression )? ']'
            {
            dbg.location(310,5);
            match(input,44,FOLLOW_44_in_slice2724); if (state.failed) return ;
            dbg.location(310,9);
            pushFollow(FOLLOW_expression_in_slice2726);
            expression();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(310,20);
            match(input,63,FOLLOW_63_in_slice2728); if (state.failed) return ;
            dbg.location(310,24);
            // /home/alex/Desktop/Go.g:310:24: ( expression )?
            int alt48=2;
            try { dbg.enterSubRule(48);
            try { dbg.enterDecision(48);

            int LA48_0 = input.LA(1);

            if ( (LA48_0==Identifier||LA48_0==Int_lit||(LA48_0>=Float_lit && LA48_0<=Imaginary_lit)||LA48_0==Char_lit||LA48_0==String_lit||LA48_0==Unary_op||LA48_0==42||LA48_0==44||LA48_0==46||LA48_0==51||LA48_0==55) ) {
                alt48=1;
            }
            } finally {dbg.exitDecision(48);}

            switch (alt48) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:310:26: expression
                    {
                    dbg.location(310,26);
                    pushFollow(FOLLOW_expression_in_slice2732);
                    expression();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(48);}

            dbg.location(310,40);
            match(input,45,FOLLOW_45_in_slice2737); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 63, slice_StartIndex); }
        }
        dbg.location(310, 44);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "slice");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "slice"


    // $ANTLR start "typeAssertion"
    // /home/alex/Desktop/Go.g:311:1: typeAssertion : '.' '(' type ')' ;
    public final void typeAssertion() throws RecognitionException {
        int typeAssertion_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "typeAssertion");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(311, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 64) ) { return ; }
            // /home/alex/Desktop/Go.g:312:2: ( '.' '(' type ')' )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:312:5: '.' '(' type ')'
            {
            dbg.location(312,5);
            match(input,62,FOLLOW_62_in_typeAssertion2749); if (state.failed) return ;
            dbg.location(312,9);
            match(input,42,FOLLOW_42_in_typeAssertion2751); if (state.failed) return ;
            dbg.location(312,13);
            pushFollow(FOLLOW_type_in_typeAssertion2753);
            type();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(312,18);
            match(input,43,FOLLOW_43_in_typeAssertion2755); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 64, typeAssertion_StartIndex); }
        }
        dbg.location(312, 22);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "typeAssertion");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "typeAssertion"


    // $ANTLR start "call"
    // /home/alex/Desktop/Go.g:313:1: call : '(' ( expressionList ( ',' )? )? ')' ;
    public final void call() throws RecognitionException {
        int call_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "call");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(313, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 65) ) { return ; }
            // /home/alex/Desktop/Go.g:314:2: ( '(' ( expressionList ( ',' )? )? ')' )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:314:5: '(' ( expressionList ( ',' )? )? ')'
            {
            dbg.location(314,5);
            match(input,42,FOLLOW_42_in_call2776); if (state.failed) return ;
            dbg.location(314,9);
            // /home/alex/Desktop/Go.g:314:9: ( expressionList ( ',' )? )?
            int alt50=2;
            try { dbg.enterSubRule(50);
            try { dbg.enterDecision(50);

            int LA50_0 = input.LA(1);

            if ( (LA50_0==Identifier||LA50_0==Int_lit||(LA50_0>=Float_lit && LA50_0<=Imaginary_lit)||LA50_0==Char_lit||LA50_0==String_lit||LA50_0==Unary_op||LA50_0==42||LA50_0==44||LA50_0==46||LA50_0==51||LA50_0==55) ) {
                alt50=1;
            }
            } finally {dbg.exitDecision(50);}

            switch (alt50) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:314:11: expressionList ( ',' )?
                    {
                    dbg.location(314,11);
                    pushFollow(FOLLOW_expressionList_in_call2780);
                    expressionList();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(314,26);
                    // /home/alex/Desktop/Go.g:314:26: ( ',' )?
                    int alt49=2;
                    try { dbg.enterSubRule(49);
                    try { dbg.enterDecision(49);

                    int LA49_0 = input.LA(1);

                    if ( (LA49_0==52) ) {
                        alt49=1;
                    }
                    } finally {dbg.exitDecision(49);}

                    switch (alt49) {
                        case 1 :
                            dbg.enterAlt(1);

                            // /home/alex/Desktop/Go.g:314:28: ','
                            {
                            dbg.location(314,28);
                            match(input,52,FOLLOW_52_in_call2784); if (state.failed) return ;

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(49);}


                    }
                    break;

            }
            } finally {dbg.exitSubRule(50);}

            dbg.location(314,38);
            match(input,43,FOLLOW_43_in_call2792); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 65, call_StartIndex); }
        }
        dbg.location(314, 42);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "call");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "call"


    // $ANTLR start "expression"
    // /home/alex/Desktop/Go.g:317:1: expression : ( unaryExpr ) ( Binary_op unaryExpr )* ;
    public final void expression() throws RecognitionException {
        int expression_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "expression");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(317, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 66) ) { return ; }
            // /home/alex/Desktop/Go.g:318:2: ( ( unaryExpr ) ( Binary_op unaryExpr )* )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:318:5: ( unaryExpr ) ( Binary_op unaryExpr )*
            {
            dbg.location(318,5);
            // /home/alex/Desktop/Go.g:318:5: ( unaryExpr )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:318:6: unaryExpr
            {
            dbg.location(318,6);
            pushFollow(FOLLOW_unaryExpr_in_expression2806);
            unaryExpr();

            state._fsp--;
            if (state.failed) return ;

            }

            dbg.location(318,17);
            // /home/alex/Desktop/Go.g:318:17: ( Binary_op unaryExpr )*
            try { dbg.enterSubRule(51);

            loop51:
            do {
                int alt51=2;
                try { dbg.enterDecision(51);

                int LA51_0 = input.LA(1);

                if ( (LA51_0==Binary_op) ) {
                    alt51=1;
                }


                } finally {dbg.exitDecision(51);}

                switch (alt51) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // /home/alex/Desktop/Go.g:318:18: Binary_op unaryExpr
            	    {
            	    dbg.location(318,18);
            	    match(input,Binary_op,FOLLOW_Binary_op_in_expression2810); if (state.failed) return ;
            	    dbg.location(318,28);
            	    pushFollow(FOLLOW_unaryExpr_in_expression2812);
            	    unaryExpr();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop51;
                }
            } while (true);
            } finally {dbg.exitSubRule(51);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 66, expression_StartIndex); }
        }
        dbg.location(318, 40);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "expression");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "expression"


    // $ANTLR start "unaryExpr"
    // /home/alex/Desktop/Go.g:319:1: unaryExpr : ( primaryExpr | Unary_op unaryExpr );
    public final void unaryExpr() throws RecognitionException {
        int unaryExpr_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "unaryExpr");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(319, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 67) ) { return ; }
            // /home/alex/Desktop/Go.g:320:2: ( primaryExpr | Unary_op unaryExpr )
            int alt52=2;
            try { dbg.enterDecision(52);

            int LA52_0 = input.LA(1);

            if ( (LA52_0==Identifier||LA52_0==Int_lit||(LA52_0>=Float_lit && LA52_0<=Imaginary_lit)||LA52_0==Char_lit||LA52_0==String_lit||LA52_0==42||LA52_0==44||LA52_0==46||LA52_0==51||LA52_0==55) ) {
                alt52=1;
            }
            else if ( (LA52_0==Unary_op) ) {
                alt52=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 52, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(52);}

            switch (alt52) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:320:5: primaryExpr
                    {
                    dbg.location(320,5);
                    pushFollow(FOLLOW_primaryExpr_in_unaryExpr2826);
                    primaryExpr();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // /home/alex/Desktop/Go.g:320:19: Unary_op unaryExpr
                    {
                    dbg.location(320,19);
                    match(input,Unary_op,FOLLOW_Unary_op_in_unaryExpr2830); if (state.failed) return ;
                    dbg.location(320,28);
                    pushFollow(FOLLOW_unaryExpr_in_unaryExpr2832);
                    unaryExpr();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 67, unaryExpr_StartIndex); }
        }
        dbg.location(320, 38);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "unaryExpr");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "unaryExpr"


    // $ANTLR start "methodExpr"
    // /home/alex/Desktop/Go.g:343:1: methodExpr : receiverType '.' methodName ;
    public final void methodExpr() throws RecognitionException {
        int methodExpr_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "methodExpr");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(343, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 68) ) { return ; }
            // /home/alex/Desktop/Go.g:344:2: ( receiverType '.' methodName )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:344:5: receiverType '.' methodName
            {
            dbg.location(344,5);
            pushFollow(FOLLOW_receiverType_in_methodExpr3061);
            receiverType();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(344,18);
            match(input,62,FOLLOW_62_in_methodExpr3063); if (state.failed) return ;
            dbg.location(344,22);
            pushFollow(FOLLOW_methodName_in_methodExpr3065);
            methodName();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 68, methodExpr_StartIndex); }
        }
        dbg.location(344, 33);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "methodExpr");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "methodExpr"


    // $ANTLR start "receiverType"
    // /home/alex/Desktop/Go.g:345:1: receiverType : ( typeName | '(' '*' typeName ')' );
    public final void receiverType() throws RecognitionException {
        int receiverType_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "receiverType");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(345, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 69) ) { return ; }
            // /home/alex/Desktop/Go.g:346:2: ( typeName | '(' '*' typeName ')' )
            int alt53=2;
            try { dbg.enterDecision(53);

            int LA53_0 = input.LA(1);

            if ( (LA53_0==Identifier) ) {
                alt53=1;
            }
            else if ( (LA53_0==42) ) {
                alt53=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 53, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(53);}

            switch (alt53) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:346:5: typeName
                    {
                    dbg.location(346,5);
                    pushFollow(FOLLOW_typeName_in_receiverType3077);
                    typeName();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // /home/alex/Desktop/Go.g:346:16: '(' '*' typeName ')'
                    {
                    dbg.location(346,16);
                    match(input,42,FOLLOW_42_in_receiverType3081); if (state.failed) return ;
                    dbg.location(346,20);
                    match(input,50,FOLLOW_50_in_receiverType3083); if (state.failed) return ;
                    dbg.location(346,24);
                    pushFollow(FOLLOW_typeName_in_receiverType3085);
                    typeName();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(346,33);
                    match(input,43,FOLLOW_43_in_receiverType3087); if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 69, receiverType_StartIndex); }
        }
        dbg.location(346, 37);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "receiverType");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "receiverType"


    // $ANTLR start "conversion"
    // /home/alex/Desktop/Go.g:348:1: conversion : literalType '(' expression ')' ;
    public final void conversion() throws RecognitionException {
        int conversion_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "conversion");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(348, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 70) ) { return ; }
            // /home/alex/Desktop/Go.g:349:2: ( literalType '(' expression ')' )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:349:5: literalType '(' expression ')'
            {
            dbg.location(349,5);
            pushFollow(FOLLOW_literalType_in_conversion3099);
            literalType();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(349,17);
            match(input,42,FOLLOW_42_in_conversion3101); if (state.failed) return ;
            dbg.location(349,21);
            pushFollow(FOLLOW_expression_in_conversion3103);
            expression();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(349,32);
            match(input,43,FOLLOW_43_in_conversion3105); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 70, conversion_StartIndex); }
        }
        dbg.location(349, 36);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "conversion");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "conversion"


    // $ANTLR start "statement"
    // /home/alex/Desktop/Go.g:351:1: statement : ( declaration | labeledStmt | simpleStmt | goStmt | returnStmt | breakStmt | continueStmt | gotoStmt | fallthroughStmt | block | ifStmt | switchStmt | selectStmt | forStmt | deferStmt );
    public final void statement() throws RecognitionException {
        int statement_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "statement");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(351, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 71) ) { return ; }
            // /home/alex/Desktop/Go.g:352:2: ( declaration | labeledStmt | simpleStmt | goStmt | returnStmt | breakStmt | continueStmt | gotoStmt | fallthroughStmt | block | ifStmt | switchStmt | selectStmt | forStmt | deferStmt )
            int alt54=15;
            try { dbg.enterDecision(54);

            try {
                isCyclicDecision = true;
                alt54 = dfa54.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(54);}

            switch (alt54) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:353:2: declaration
                    {
                    dbg.location(353,2);
                    pushFollow(FOLLOW_declaration_in_statement3118);
                    declaration();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // /home/alex/Desktop/Go.g:353:16: labeledStmt
                    {
                    dbg.location(353,16);
                    pushFollow(FOLLOW_labeledStmt_in_statement3122);
                    labeledStmt();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 3 :
                    dbg.enterAlt(3);

                    // /home/alex/Desktop/Go.g:353:30: simpleStmt
                    {
                    dbg.location(353,30);
                    pushFollow(FOLLOW_simpleStmt_in_statement3126);
                    simpleStmt();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 4 :
                    dbg.enterAlt(4);

                    // /home/alex/Desktop/Go.g:354:2: goStmt
                    {
                    dbg.location(354,2);
                    pushFollow(FOLLOW_goStmt_in_statement3131);
                    goStmt();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 5 :
                    dbg.enterAlt(5);

                    // /home/alex/Desktop/Go.g:354:11: returnStmt
                    {
                    dbg.location(354,11);
                    pushFollow(FOLLOW_returnStmt_in_statement3135);
                    returnStmt();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 6 :
                    dbg.enterAlt(6);

                    // /home/alex/Desktop/Go.g:354:24: breakStmt
                    {
                    dbg.location(354,24);
                    pushFollow(FOLLOW_breakStmt_in_statement3139);
                    breakStmt();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 7 :
                    dbg.enterAlt(7);

                    // /home/alex/Desktop/Go.g:354:36: continueStmt
                    {
                    dbg.location(354,36);
                    pushFollow(FOLLOW_continueStmt_in_statement3143);
                    continueStmt();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 8 :
                    dbg.enterAlt(8);

                    // /home/alex/Desktop/Go.g:354:51: gotoStmt
                    {
                    dbg.location(354,51);
                    pushFollow(FOLLOW_gotoStmt_in_statement3147);
                    gotoStmt();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 9 :
                    dbg.enterAlt(9);

                    // /home/alex/Desktop/Go.g:355:2: fallthroughStmt
                    {
                    dbg.location(355,2);
                    pushFollow(FOLLOW_fallthroughStmt_in_statement3152);
                    fallthroughStmt();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 10 :
                    dbg.enterAlt(10);

                    // /home/alex/Desktop/Go.g:355:20: block
                    {
                    dbg.location(355,20);
                    pushFollow(FOLLOW_block_in_statement3156);
                    block();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 11 :
                    dbg.enterAlt(11);

                    // /home/alex/Desktop/Go.g:355:28: ifStmt
                    {
                    dbg.location(355,28);
                    pushFollow(FOLLOW_ifStmt_in_statement3160);
                    ifStmt();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 12 :
                    dbg.enterAlt(12);

                    // /home/alex/Desktop/Go.g:355:37: switchStmt
                    {
                    dbg.location(355,37);
                    pushFollow(FOLLOW_switchStmt_in_statement3164);
                    switchStmt();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 13 :
                    dbg.enterAlt(13);

                    // /home/alex/Desktop/Go.g:355:50: selectStmt
                    {
                    dbg.location(355,50);
                    pushFollow(FOLLOW_selectStmt_in_statement3168);
                    selectStmt();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 14 :
                    dbg.enterAlt(14);

                    // /home/alex/Desktop/Go.g:355:63: forStmt
                    {
                    dbg.location(355,63);
                    pushFollow(FOLLOW_forStmt_in_statement3172);
                    forStmt();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 15 :
                    dbg.enterAlt(15);

                    // /home/alex/Desktop/Go.g:356:2: deferStmt
                    {
                    dbg.location(356,2);
                    pushFollow(FOLLOW_deferStmt_in_statement3177);
                    deferStmt();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 71, statement_StartIndex); }
        }
        dbg.location(356, 12);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "statement");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "statement"


    // $ANTLR start "simpleStmt"
    // /home/alex/Desktop/Go.g:358:1: simpleStmt : ( emptyStmt | expressionStmt | incDecStmt | assignment | shortVarDecl );
    public final void simpleStmt() throws RecognitionException {
        int simpleStmt_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "simpleStmt");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(358, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 72) ) { return ; }
            // /home/alex/Desktop/Go.g:359:2: ( emptyStmt | expressionStmt | incDecStmt | assignment | shortVarDecl )
            int alt55=5;
            try { dbg.enterDecision(55);

            try {
                isCyclicDecision = true;
                alt55 = dfa55.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(55);}

            switch (alt55) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:359:5: emptyStmt
                    {
                    dbg.location(359,5);
                    pushFollow(FOLLOW_emptyStmt_in_simpleStmt3189);
                    emptyStmt();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // /home/alex/Desktop/Go.g:359:17: expressionStmt
                    {
                    dbg.location(359,17);
                    pushFollow(FOLLOW_expressionStmt_in_simpleStmt3193);
                    expressionStmt();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 3 :
                    dbg.enterAlt(3);

                    // /home/alex/Desktop/Go.g:359:34: incDecStmt
                    {
                    dbg.location(359,34);
                    pushFollow(FOLLOW_incDecStmt_in_simpleStmt3197);
                    incDecStmt();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 4 :
                    dbg.enterAlt(4);

                    // /home/alex/Desktop/Go.g:359:47: assignment
                    {
                    dbg.location(359,47);
                    pushFollow(FOLLOW_assignment_in_simpleStmt3201);
                    assignment();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 5 :
                    dbg.enterAlt(5);

                    // /home/alex/Desktop/Go.g:359:60: shortVarDecl
                    {
                    dbg.location(359,60);
                    pushFollow(FOLLOW_shortVarDecl_in_simpleStmt3205);
                    shortVarDecl();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 72, simpleStmt_StartIndex); }
        }
        dbg.location(359, 73);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "simpleStmt");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "simpleStmt"


    // $ANTLR start "emptyStmt"
    // /home/alex/Desktop/Go.g:362:1: emptyStmt : ;
    public final void emptyStmt() throws RecognitionException {
        int emptyStmt_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "emptyStmt");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(362, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 73) ) { return ; }
            // /home/alex/Desktop/Go.g:363:2: ()
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:363:5: 
            {
            }

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 73, emptyStmt_StartIndex); }
        }
        dbg.location(363, 5);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "emptyStmt");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "emptyStmt"


    // $ANTLR start "labeledStmt"
    // /home/alex/Desktop/Go.g:365:1: labeledStmt : label ':' statement ;
    public final void labeledStmt() throws RecognitionException {
        int labeledStmt_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "labeledStmt");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(365, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 74) ) { return ; }
            // /home/alex/Desktop/Go.g:366:2: ( label ':' statement )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:366:5: label ':' statement
            {
            dbg.location(366,5);
            pushFollow(FOLLOW_label_in_labeledStmt3228);
            label();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(366,11);
            match(input,63,FOLLOW_63_in_labeledStmt3230); if (state.failed) return ;
            dbg.location(366,15);
            pushFollow(FOLLOW_statement_in_labeledStmt3232);
            statement();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 74, labeledStmt_StartIndex); }
        }
        dbg.location(366, 25);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "labeledStmt");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "labeledStmt"


    // $ANTLR start "label"
    // /home/alex/Desktop/Go.g:367:1: label : Identifier ;
    public final void label() throws RecognitionException {
        int label_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "label");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(367, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 75) ) { return ; }
            // /home/alex/Desktop/Go.g:368:2: ( Identifier )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:368:5: Identifier
            {
            dbg.location(368,5);
            match(input,Identifier,FOLLOW_Identifier_in_label3249); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 75, label_StartIndex); }
        }
        dbg.location(368, 16);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "label");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "label"


    // $ANTLR start "expressionStmt"
    // /home/alex/Desktop/Go.g:370:1: expressionStmt : expression ;
    public final void expressionStmt() throws RecognitionException {
        int expressionStmt_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "expressionStmt");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(370, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 76) ) { return ; }
            // /home/alex/Desktop/Go.g:371:2: ( expression )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:371:5: expression
            {
            dbg.location(371,5);
            pushFollow(FOLLOW_expression_in_expressionStmt3261);
            expression();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 76, expressionStmt_StartIndex); }
        }
        dbg.location(371, 16);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "expressionStmt");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "expressionStmt"


    // $ANTLR start "incDecStmt"
    // /home/alex/Desktop/Go.g:373:1: incDecStmt : expression ( '++' | '--' ) ;
    public final void incDecStmt() throws RecognitionException {
        int incDecStmt_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "incDecStmt");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(373, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 77) ) { return ; }
            // /home/alex/Desktop/Go.g:374:2: ( expression ( '++' | '--' ) )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:374:5: expression ( '++' | '--' )
            {
            dbg.location(374,5);
            pushFollow(FOLLOW_expression_in_incDecStmt3273);
            expression();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(374,16);
            if ( (input.LA(1)>=64 && input.LA(1)<=65) ) {
                input.consume();
                state.errorRecovery=false;state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                dbg.recognitionException(mse);
                throw mse;
            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 77, incDecStmt_StartIndex); }
        }
        dbg.location(374, 32);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "incDecStmt");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "incDecStmt"


    // $ANTLR start "assignment"
    // /home/alex/Desktop/Go.g:376:1: assignment : expressionList Assign_op expressionList ;
    public final void assignment() throws RecognitionException {
        int assignment_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "assignment");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(376, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 78) ) { return ; }
            // /home/alex/Desktop/Go.g:377:2: ( expressionList Assign_op expressionList )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:377:5: expressionList Assign_op expressionList
            {
            dbg.location(377,5);
            pushFollow(FOLLOW_expressionList_in_assignment3295);
            expressionList();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(377,20);
            match(input,Assign_op,FOLLOW_Assign_op_in_assignment3297); if (state.failed) return ;
            dbg.location(377,30);
            pushFollow(FOLLOW_expressionList_in_assignment3299);
            expressionList();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 78, assignment_StartIndex); }
        }
        dbg.location(377, 45);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "assignment");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "assignment"


    // $ANTLR start "ifStmt"
    // /home/alex/Desktop/Go.g:382:1: ifStmt : 'if' ( simpleStmt ';' )? ( expression )? block ( 'else' statement )? ;
    public final void ifStmt() throws RecognitionException {
        int ifStmt_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "ifStmt");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(382, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 79) ) { return ; }
            // /home/alex/Desktop/Go.g:383:2: ( 'if' ( simpleStmt ';' )? ( expression )? block ( 'else' statement )? )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:383:5: 'if' ( simpleStmt ';' )? ( expression )? block ( 'else' statement )?
            {
            dbg.location(383,5);
            match(input,66,FOLLOW_66_in_ifStmt3337); if (state.failed) return ;
            dbg.location(383,10);
            // /home/alex/Desktop/Go.g:383:10: ( simpleStmt ';' )?
            int alt56=2;
            try { dbg.enterSubRule(56);
            try { dbg.enterDecision(56);

            try {
                isCyclicDecision = true;
                alt56 = dfa56.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(56);}

            switch (alt56) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:383:12: simpleStmt ';'
                    {
                    dbg.location(383,12);
                    pushFollow(FOLLOW_simpleStmt_in_ifStmt3341);
                    simpleStmt();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(383,23);
                    match(input,48,FOLLOW_48_in_ifStmt3343); if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(56);}

            dbg.location(383,30);
            // /home/alex/Desktop/Go.g:383:30: ( expression )?
            int alt57=2;
            try { dbg.enterSubRule(57);
            try { dbg.enterDecision(57);

            int LA57_0 = input.LA(1);

            if ( (LA57_0==Identifier||LA57_0==Int_lit||(LA57_0>=Float_lit && LA57_0<=Imaginary_lit)||LA57_0==Char_lit||LA57_0==String_lit||LA57_0==Unary_op||LA57_0==42||LA57_0==44||LA57_0==46||LA57_0==51||LA57_0==55) ) {
                alt57=1;
            }
            } finally {dbg.exitDecision(57);}

            switch (alt57) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:383:32: expression
                    {
                    dbg.location(383,32);
                    pushFollow(FOLLOW_expression_in_ifStmt3350);
                    expression();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(57);}

            dbg.location(383,46);
            pushFollow(FOLLOW_block_in_ifStmt3355);
            block();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(383,52);
            // /home/alex/Desktop/Go.g:383:52: ( 'else' statement )?
            int alt58=2;
            try { dbg.enterSubRule(58);
            try { dbg.enterDecision(58);

            int LA58_0 = input.LA(1);

            if ( (LA58_0==67) ) {
                alt58=1;
            }
            } finally {dbg.exitDecision(58);}

            switch (alt58) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:383:54: 'else' statement
                    {
                    dbg.location(383,54);
                    match(input,67,FOLLOW_67_in_ifStmt3359); if (state.failed) return ;
                    dbg.location(383,61);
                    pushFollow(FOLLOW_statement_in_ifStmt3361);
                    statement();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(58);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 79, ifStmt_StartIndex); }
        }
        dbg.location(383, 74);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "ifStmt");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "ifStmt"


    // $ANTLR start "switchStmt"
    // /home/alex/Desktop/Go.g:385:1: switchStmt : ( exprSwitchStmt | typeSwitchStmt );
    public final void switchStmt() throws RecognitionException {
        int switchStmt_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "switchStmt");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(385, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 80) ) { return ; }
            // /home/alex/Desktop/Go.g:386:2: ( exprSwitchStmt | typeSwitchStmt )
            int alt59=2;
            try { dbg.enterDecision(59);

            int LA59_0 = input.LA(1);

            if ( (LA59_0==68) ) {
                int LA59_1 = input.LA(2);

                if ( (synpred103_Go()) ) {
                    alt59=1;
                }
                else if ( (true) ) {
                    alt59=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 59, 1, input);

                    dbg.recognitionException(nvae);
                    throw nvae;
                }
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 59, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(59);}

            switch (alt59) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:386:5: exprSwitchStmt
                    {
                    dbg.location(386,5);
                    pushFollow(FOLLOW_exprSwitchStmt_in_switchStmt3376);
                    exprSwitchStmt();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // /home/alex/Desktop/Go.g:386:22: typeSwitchStmt
                    {
                    dbg.location(386,22);
                    pushFollow(FOLLOW_typeSwitchStmt_in_switchStmt3380);
                    typeSwitchStmt();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 80, switchStmt_StartIndex); }
        }
        dbg.location(386, 37);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "switchStmt");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "switchStmt"


    // $ANTLR start "exprSwitchStmt"
    // /home/alex/Desktop/Go.g:388:1: exprSwitchStmt : 'switch' ( simpleStmt ';' )? ( expression )? '{' ( exprCaseClause )* '}' ;
    public final void exprSwitchStmt() throws RecognitionException {
        int exprSwitchStmt_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "exprSwitchStmt");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(388, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 81) ) { return ; }
            // /home/alex/Desktop/Go.g:389:2: ( 'switch' ( simpleStmt ';' )? ( expression )? '{' ( exprCaseClause )* '}' )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:389:5: 'switch' ( simpleStmt ';' )? ( expression )? '{' ( exprCaseClause )* '}'
            {
            dbg.location(389,5);
            match(input,68,FOLLOW_68_in_exprSwitchStmt3392); if (state.failed) return ;
            dbg.location(389,14);
            // /home/alex/Desktop/Go.g:389:14: ( simpleStmt ';' )?
            int alt60=2;
            try { dbg.enterSubRule(60);
            try { dbg.enterDecision(60);

            try {
                isCyclicDecision = true;
                alt60 = dfa60.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(60);}

            switch (alt60) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:389:16: simpleStmt ';'
                    {
                    dbg.location(389,16);
                    pushFollow(FOLLOW_simpleStmt_in_exprSwitchStmt3396);
                    simpleStmt();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(389,27);
                    match(input,48,FOLLOW_48_in_exprSwitchStmt3398); if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(60);}

            dbg.location(389,34);
            // /home/alex/Desktop/Go.g:389:34: ( expression )?
            int alt61=2;
            try { dbg.enterSubRule(61);
            try { dbg.enterDecision(61);

            int LA61_0 = input.LA(1);

            if ( (LA61_0==Identifier||LA61_0==Int_lit||(LA61_0>=Float_lit && LA61_0<=Imaginary_lit)||LA61_0==Char_lit||LA61_0==String_lit||LA61_0==Unary_op||LA61_0==42||LA61_0==44||LA61_0==46||LA61_0==51||LA61_0==55) ) {
                alt61=1;
            }
            } finally {dbg.exitDecision(61);}

            switch (alt61) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:389:36: expression
                    {
                    dbg.location(389,36);
                    pushFollow(FOLLOW_expression_in_exprSwitchStmt3405);
                    expression();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(61);}

            dbg.location(389,50);
            match(input,47,FOLLOW_47_in_exprSwitchStmt3410); if (state.failed) return ;
            dbg.location(389,54);
            // /home/alex/Desktop/Go.g:389:54: ( exprCaseClause )*
            try { dbg.enterSubRule(62);

            loop62:
            do {
                int alt62=2;
                try { dbg.enterDecision(62);

                int LA62_0 = input.LA(1);

                if ( ((LA62_0>=69 && LA62_0<=70)) ) {
                    alt62=1;
                }


                } finally {dbg.exitDecision(62);}

                switch (alt62) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // /home/alex/Desktop/Go.g:389:56: exprCaseClause
            	    {
            	    dbg.location(389,56);
            	    pushFollow(FOLLOW_exprCaseClause_in_exprSwitchStmt3414);
            	    exprCaseClause();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop62;
                }
            } while (true);
            } finally {dbg.exitSubRule(62);}

            dbg.location(389,74);
            match(input,49,FOLLOW_49_in_exprSwitchStmt3419); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 81, exprSwitchStmt_StartIndex); }
        }
        dbg.location(389, 78);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "exprSwitchStmt");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "exprSwitchStmt"


    // $ANTLR start "exprCaseClause"
    // /home/alex/Desktop/Go.g:390:1: exprCaseClause : exprSwitchCase ':' ( statement ';' )? ;
    public final void exprCaseClause() throws RecognitionException {
        int exprCaseClause_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "exprCaseClause");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(390, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 82) ) { return ; }
            // /home/alex/Desktop/Go.g:391:2: ( exprSwitchCase ':' ( statement ';' )? )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:391:5: exprSwitchCase ':' ( statement ';' )?
            {
            dbg.location(391,5);
            pushFollow(FOLLOW_exprSwitchCase_in_exprCaseClause3430);
            exprSwitchCase();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(391,20);
            match(input,63,FOLLOW_63_in_exprCaseClause3432); if (state.failed) return ;
            dbg.location(391,24);
            // /home/alex/Desktop/Go.g:391:24: ( statement ';' )?
            int alt63=2;
            try { dbg.enterSubRule(63);
            try { dbg.enterDecision(63);

            int LA63_0 = input.LA(1);

            if ( (LA63_0==Identifier||LA63_0==Int_lit||(LA63_0>=Float_lit && LA63_0<=Imaginary_lit)||LA63_0==Char_lit||LA63_0==String_lit||LA63_0==Unary_op||LA63_0==42||LA63_0==44||(LA63_0>=46 && LA63_0<=48)||LA63_0==51||LA63_0==55||LA63_0==57||(LA63_0>=59 && LA63_0<=60)||LA63_0==66||LA63_0==68||LA63_0==71||(LA63_0>=73 && LA63_0<=80)) ) {
                alt63=1;
            }
            } finally {dbg.exitDecision(63);}

            switch (alt63) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:391:26: statement ';'
                    {
                    dbg.location(391,26);
                    pushFollow(FOLLOW_statement_in_exprCaseClause3436);
                    statement();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(391,36);
                    match(input,48,FOLLOW_48_in_exprCaseClause3438); if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(63);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 82, exprCaseClause_StartIndex); }
        }
        dbg.location(391, 43);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "exprCaseClause");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "exprCaseClause"


    // $ANTLR start "exprSwitchCase"
    // /home/alex/Desktop/Go.g:392:1: exprSwitchCase : ( 'case' expressionList | 'default' );
    public final void exprSwitchCase() throws RecognitionException {
        int exprSwitchCase_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "exprSwitchCase");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(392, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 83) ) { return ; }
            // /home/alex/Desktop/Go.g:393:2: ( 'case' expressionList | 'default' )
            int alt64=2;
            try { dbg.enterDecision(64);

            int LA64_0 = input.LA(1);

            if ( (LA64_0==69) ) {
                alt64=1;
            }
            else if ( (LA64_0==70) ) {
                alt64=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 64, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(64);}

            switch (alt64) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:393:5: 'case' expressionList
                    {
                    dbg.location(393,5);
                    match(input,69,FOLLOW_69_in_exprSwitchCase3452); if (state.failed) return ;
                    dbg.location(393,12);
                    pushFollow(FOLLOW_expressionList_in_exprSwitchCase3454);
                    expressionList();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // /home/alex/Desktop/Go.g:393:29: 'default'
                    {
                    dbg.location(393,29);
                    match(input,70,FOLLOW_70_in_exprSwitchCase3458); if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 83, exprSwitchCase_StartIndex); }
        }
        dbg.location(393, 39);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "exprSwitchCase");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "exprSwitchCase"


    // $ANTLR start "typeSwitchStmt"
    // /home/alex/Desktop/Go.g:395:1: typeSwitchStmt : 'switch' ( simpleStmt ';' )? typeSwitchGuard '{' ( typeCaseClause )* '}' ;
    public final void typeSwitchStmt() throws RecognitionException {
        int typeSwitchStmt_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "typeSwitchStmt");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(395, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 84) ) { return ; }
            // /home/alex/Desktop/Go.g:396:2: ( 'switch' ( simpleStmt ';' )? typeSwitchGuard '{' ( typeCaseClause )* '}' )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:396:5: 'switch' ( simpleStmt ';' )? typeSwitchGuard '{' ( typeCaseClause )* '}'
            {
            dbg.location(396,5);
            match(input,68,FOLLOW_68_in_typeSwitchStmt3471); if (state.failed) return ;
            dbg.location(396,14);
            // /home/alex/Desktop/Go.g:396:14: ( simpleStmt ';' )?
            int alt65=2;
            try { dbg.enterSubRule(65);
            try { dbg.enterDecision(65);

            try {
                isCyclicDecision = true;
                alt65 = dfa65.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(65);}

            switch (alt65) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:396:16: simpleStmt ';'
                    {
                    dbg.location(396,16);
                    pushFollow(FOLLOW_simpleStmt_in_typeSwitchStmt3475);
                    simpleStmt();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(396,27);
                    match(input,48,FOLLOW_48_in_typeSwitchStmt3477); if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(65);}

            dbg.location(396,34);
            pushFollow(FOLLOW_typeSwitchGuard_in_typeSwitchStmt3482);
            typeSwitchGuard();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(396,50);
            match(input,47,FOLLOW_47_in_typeSwitchStmt3484); if (state.failed) return ;
            dbg.location(396,54);
            // /home/alex/Desktop/Go.g:396:54: ( typeCaseClause )*
            try { dbg.enterSubRule(66);

            loop66:
            do {
                int alt66=2;
                try { dbg.enterDecision(66);

                int LA66_0 = input.LA(1);

                if ( ((LA66_0>=69 && LA66_0<=70)) ) {
                    alt66=1;
                }


                } finally {dbg.exitDecision(66);}

                switch (alt66) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // /home/alex/Desktop/Go.g:396:56: typeCaseClause
            	    {
            	    dbg.location(396,56);
            	    pushFollow(FOLLOW_typeCaseClause_in_typeSwitchStmt3488);
            	    typeCaseClause();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop66;
                }
            } while (true);
            } finally {dbg.exitSubRule(66);}

            dbg.location(396,74);
            match(input,49,FOLLOW_49_in_typeSwitchStmt3493); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 84, typeSwitchStmt_StartIndex); }
        }
        dbg.location(396, 78);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "typeSwitchStmt");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "typeSwitchStmt"


    // $ANTLR start "typeSwitchGuard"
    // /home/alex/Desktop/Go.g:397:1: typeSwitchGuard : ( Identifier ':=' )? primaryExpr '.' '(' 'type' ')' ;
    public final void typeSwitchGuard() throws RecognitionException {
        int typeSwitchGuard_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "typeSwitchGuard");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(397, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 85) ) { return ; }
            // /home/alex/Desktop/Go.g:398:2: ( ( Identifier ':=' )? primaryExpr '.' '(' 'type' ')' )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:398:4: ( Identifier ':=' )? primaryExpr '.' '(' 'type' ')'
            {
            dbg.location(398,4);
            // /home/alex/Desktop/Go.g:398:4: ( Identifier ':=' )?
            int alt67=2;
            try { dbg.enterSubRule(67);
            try { dbg.enterDecision(67);

            int LA67_0 = input.LA(1);

            if ( (LA67_0==Identifier) ) {
                int LA67_1 = input.LA(2);

                if ( (LA67_1==61) ) {
                    alt67=1;
                }
            }
            } finally {dbg.exitDecision(67);}

            switch (alt67) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:398:6: Identifier ':='
                    {
                    dbg.location(398,6);
                    match(input,Identifier,FOLLOW_Identifier_in_typeSwitchGuard3505); if (state.failed) return ;
                    dbg.location(398,17);
                    match(input,61,FOLLOW_61_in_typeSwitchGuard3507); if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(67);}

            dbg.location(398,25);
            pushFollow(FOLLOW_primaryExpr_in_typeSwitchGuard3512);
            primaryExpr();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(398,37);
            match(input,62,FOLLOW_62_in_typeSwitchGuard3514); if (state.failed) return ;
            dbg.location(398,41);
            match(input,42,FOLLOW_42_in_typeSwitchGuard3516); if (state.failed) return ;
            dbg.location(398,45);
            match(input,59,FOLLOW_59_in_typeSwitchGuard3518); if (state.failed) return ;
            dbg.location(398,52);
            match(input,43,FOLLOW_43_in_typeSwitchGuard3520); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 85, typeSwitchGuard_StartIndex); }
        }
        dbg.location(398, 56);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "typeSwitchGuard");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "typeSwitchGuard"


    // $ANTLR start "typeCaseClause"
    // /home/alex/Desktop/Go.g:399:1: typeCaseClause : typeSwitchCase ':' ( statement ';' )* ;
    public final void typeCaseClause() throws RecognitionException {
        int typeCaseClause_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "typeCaseClause");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(399, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 86) ) { return ; }
            // /home/alex/Desktop/Go.g:400:2: ( typeSwitchCase ':' ( statement ';' )* )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:400:4: typeSwitchCase ':' ( statement ';' )*
            {
            dbg.location(400,4);
            pushFollow(FOLLOW_typeSwitchCase_in_typeCaseClause3531);
            typeSwitchCase();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(400,19);
            match(input,63,FOLLOW_63_in_typeCaseClause3533); if (state.failed) return ;
            dbg.location(400,23);
            // /home/alex/Desktop/Go.g:400:23: ( statement ';' )*
            try { dbg.enterSubRule(68);

            loop68:
            do {
                int alt68=2;
                try { dbg.enterDecision(68);

                int LA68_0 = input.LA(1);

                if ( (LA68_0==Identifier||LA68_0==Int_lit||(LA68_0>=Float_lit && LA68_0<=Imaginary_lit)||LA68_0==Char_lit||LA68_0==String_lit||LA68_0==Unary_op||LA68_0==42||LA68_0==44||(LA68_0>=46 && LA68_0<=48)||LA68_0==51||LA68_0==55||LA68_0==57||(LA68_0>=59 && LA68_0<=60)||LA68_0==66||LA68_0==68||LA68_0==71||(LA68_0>=73 && LA68_0<=80)) ) {
                    alt68=1;
                }


                } finally {dbg.exitDecision(68);}

                switch (alt68) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // /home/alex/Desktop/Go.g:400:25: statement ';'
            	    {
            	    dbg.location(400,25);
            	    pushFollow(FOLLOW_statement_in_typeCaseClause3537);
            	    statement();

            	    state._fsp--;
            	    if (state.failed) return ;
            	    dbg.location(400,35);
            	    match(input,48,FOLLOW_48_in_typeCaseClause3539); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop68;
                }
            } while (true);
            } finally {dbg.exitSubRule(68);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 86, typeCaseClause_StartIndex); }
        }
        dbg.location(400, 42);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "typeCaseClause");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "typeCaseClause"


    // $ANTLR start "typeSwitchCase"
    // /home/alex/Desktop/Go.g:401:1: typeSwitchCase : ( 'case' typeList | 'default' );
    public final void typeSwitchCase() throws RecognitionException {
        int typeSwitchCase_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "typeSwitchCase");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(401, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 87) ) { return ; }
            // /home/alex/Desktop/Go.g:402:2: ( 'case' typeList | 'default' )
            int alt69=2;
            try { dbg.enterDecision(69);

            int LA69_0 = input.LA(1);

            if ( (LA69_0==69) ) {
                alt69=1;
            }
            else if ( (LA69_0==70) ) {
                alt69=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 69, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(69);}

            switch (alt69) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:402:4: 'case' typeList
                    {
                    dbg.location(402,4);
                    match(input,69,FOLLOW_69_in_typeSwitchCase3553); if (state.failed) return ;
                    dbg.location(402,11);
                    pushFollow(FOLLOW_typeList_in_typeSwitchCase3555);
                    typeList();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // /home/alex/Desktop/Go.g:402:22: 'default'
                    {
                    dbg.location(402,22);
                    match(input,70,FOLLOW_70_in_typeSwitchCase3559); if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 87, typeSwitchCase_StartIndex); }
        }
        dbg.location(402, 32);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "typeSwitchCase");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "typeSwitchCase"


    // $ANTLR start "typeList"
    // /home/alex/Desktop/Go.g:403:1: typeList : type ( ',' type )* ;
    public final void typeList() throws RecognitionException {
        int typeList_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "typeList");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(403, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 88) ) { return ; }
            // /home/alex/Desktop/Go.g:404:2: ( type ( ',' type )* )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:404:4: type ( ',' type )*
            {
            dbg.location(404,4);
            pushFollow(FOLLOW_type_in_typeList3576);
            type();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(404,9);
            // /home/alex/Desktop/Go.g:404:9: ( ',' type )*
            try { dbg.enterSubRule(70);

            loop70:
            do {
                int alt70=2;
                try { dbg.enterDecision(70);

                int LA70_0 = input.LA(1);

                if ( (LA70_0==52) ) {
                    alt70=1;
                }


                } finally {dbg.exitDecision(70);}

                switch (alt70) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // /home/alex/Desktop/Go.g:404:11: ',' type
            	    {
            	    dbg.location(404,11);
            	    match(input,52,FOLLOW_52_in_typeList3580); if (state.failed) return ;
            	    dbg.location(404,15);
            	    pushFollow(FOLLOW_type_in_typeList3582);
            	    type();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop70;
                }
            } while (true);
            } finally {dbg.exitSubRule(70);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 88, typeList_StartIndex); }
        }
        dbg.location(404, 23);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "typeList");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "typeList"


    // $ANTLR start "forStmt"
    // /home/alex/Desktop/Go.g:406:1: forStmt : 'for' ( condition | forClause | rangeClause )? block ;
    public final void forStmt() throws RecognitionException {
        int forStmt_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "forStmt");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(406, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 89) ) { return ; }
            // /home/alex/Desktop/Go.g:407:2: ( 'for' ( condition | forClause | rangeClause )? block )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:407:5: 'for' ( condition | forClause | rangeClause )? block
            {
            dbg.location(407,5);
            match(input,71,FOLLOW_71_in_forStmt3597); if (state.failed) return ;
            dbg.location(407,11);
            // /home/alex/Desktop/Go.g:407:11: ( condition | forClause | rangeClause )?
            int alt71=4;
            try { dbg.enterSubRule(71);
            try { dbg.enterDecision(71);

            try {
                isCyclicDecision = true;
                alt71 = dfa71.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(71);}

            switch (alt71) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:407:13: condition
                    {
                    dbg.location(407,13);
                    pushFollow(FOLLOW_condition_in_forStmt3601);
                    condition();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // /home/alex/Desktop/Go.g:407:25: forClause
                    {
                    dbg.location(407,25);
                    pushFollow(FOLLOW_forClause_in_forStmt3605);
                    forClause();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 3 :
                    dbg.enterAlt(3);

                    // /home/alex/Desktop/Go.g:407:37: rangeClause
                    {
                    dbg.location(407,37);
                    pushFollow(FOLLOW_rangeClause_in_forStmt3609);
                    rangeClause();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(71);}

            dbg.location(407,52);
            pushFollow(FOLLOW_block_in_forStmt3614);
            block();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 89, forStmt_StartIndex); }
        }
        dbg.location(407, 58);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "forStmt");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "forStmt"


    // $ANTLR start "condition"
    // /home/alex/Desktop/Go.g:408:1: condition : expression ;
    public final void condition() throws RecognitionException {
        int condition_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "condition");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(408, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 90) ) { return ; }
            // /home/alex/Desktop/Go.g:409:2: ( expression )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:409:5: expression
            {
            dbg.location(409,5);
            pushFollow(FOLLOW_expression_in_condition3625);
            expression();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 90, condition_StartIndex); }
        }
        dbg.location(409, 16);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "condition");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "condition"


    // $ANTLR start "forClause"
    // /home/alex/Desktop/Go.g:411:1: forClause : ( initStmt )? ';' ( condition )? ';' ( postStmt )? ;
    public final void forClause() throws RecognitionException {
        int forClause_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "forClause");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(411, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 91) ) { return ; }
            // /home/alex/Desktop/Go.g:412:2: ( ( initStmt )? ';' ( condition )? ';' ( postStmt )? )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:412:5: ( initStmt )? ';' ( condition )? ';' ( postStmt )?
            {
            dbg.location(412,5);
            // /home/alex/Desktop/Go.g:412:5: ( initStmt )?
            int alt72=2;
            try { dbg.enterSubRule(72);
            try { dbg.enterDecision(72);

            int LA72_0 = input.LA(1);

            if ( (LA72_0==48) ) {
                int LA72_1 = input.LA(2);

                if ( (synpred118_Go()) ) {
                    alt72=1;
                }
            }
            else if ( (LA72_0==Identifier||LA72_0==Int_lit||(LA72_0>=Float_lit && LA72_0<=Imaginary_lit)||LA72_0==Char_lit||LA72_0==String_lit||LA72_0==Unary_op||LA72_0==42||LA72_0==44||LA72_0==46||LA72_0==51||LA72_0==55) ) {
                alt72=1;
            }
            } finally {dbg.exitDecision(72);}

            switch (alt72) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:412:7: initStmt
                    {
                    dbg.location(412,7);
                    pushFollow(FOLLOW_initStmt_in_forClause3639);
                    initStmt();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(72);}

            dbg.location(412,19);
            match(input,48,FOLLOW_48_in_forClause3644); if (state.failed) return ;
            dbg.location(412,23);
            // /home/alex/Desktop/Go.g:412:23: ( condition )?
            int alt73=2;
            try { dbg.enterSubRule(73);
            try { dbg.enterDecision(73);

            int LA73_0 = input.LA(1);

            if ( (LA73_0==Identifier||LA73_0==Int_lit||(LA73_0>=Float_lit && LA73_0<=Imaginary_lit)||LA73_0==Char_lit||LA73_0==String_lit||LA73_0==Unary_op||LA73_0==42||LA73_0==44||LA73_0==46||LA73_0==51||LA73_0==55) ) {
                alt73=1;
            }
            } finally {dbg.exitDecision(73);}

            switch (alt73) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:412:25: condition
                    {
                    dbg.location(412,25);
                    pushFollow(FOLLOW_condition_in_forClause3648);
                    condition();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(73);}

            dbg.location(412,38);
            match(input,48,FOLLOW_48_in_forClause3653); if (state.failed) return ;
            dbg.location(412,42);
            // /home/alex/Desktop/Go.g:412:42: ( postStmt )?
            int alt74=2;
            try { dbg.enterSubRule(74);
            try { dbg.enterDecision(74);

            switch ( input.LA(1) ) {
                case 47:
                    {
                    int LA74_1 = input.LA(2);

                    if ( (synpred120_Go()) ) {
                        alt74=1;
                    }
                    }
                    break;
                case EOF:
                    {
                    int LA74_2 = input.LA(2);

                    if ( (synpred120_Go()) ) {
                        alt74=1;
                    }
                    }
                    break;
                case Identifier:
                case Int_lit:
                case Float_lit:
                case Imaginary_lit:
                case Char_lit:
                case String_lit:
                case Unary_op:
                case 42:
                case 44:
                case 46:
                case 51:
                case 55:
                    {
                    alt74=1;
                    }
                    break;
            }

            } finally {dbg.exitDecision(74);}

            switch (alt74) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:412:44: postStmt
                    {
                    dbg.location(412,44);
                    pushFollow(FOLLOW_postStmt_in_forClause3657);
                    postStmt();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(74);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 91, forClause_StartIndex); }
        }
        dbg.location(412, 56);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "forClause");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "forClause"


    // $ANTLR start "initStmt"
    // /home/alex/Desktop/Go.g:413:1: initStmt : simpleStmt ;
    public final void initStmt() throws RecognitionException {
        int initStmt_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "initStmt");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(413, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 92) ) { return ; }
            // /home/alex/Desktop/Go.g:414:2: ( simpleStmt )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:414:5: simpleStmt
            {
            dbg.location(414,5);
            pushFollow(FOLLOW_simpleStmt_in_initStmt3671);
            simpleStmt();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 92, initStmt_StartIndex); }
        }
        dbg.location(414, 16);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "initStmt");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "initStmt"


    // $ANTLR start "postStmt"
    // /home/alex/Desktop/Go.g:415:1: postStmt : simpleStmt ;
    public final void postStmt() throws RecognitionException {
        int postStmt_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "postStmt");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(415, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 93) ) { return ; }
            // /home/alex/Desktop/Go.g:416:2: ( simpleStmt )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:416:5: simpleStmt
            {
            dbg.location(416,5);
            pushFollow(FOLLOW_simpleStmt_in_postStmt3682);
            simpleStmt();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 93, postStmt_StartIndex); }
        }
        dbg.location(416, 16);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "postStmt");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "postStmt"


    // $ANTLR start "rangeClause"
    // /home/alex/Desktop/Go.g:418:1: rangeClause : expressionList ( '=' | ':=' ) 'range' expression ;
    public final void rangeClause() throws RecognitionException {
        int rangeClause_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "rangeClause");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(418, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 94) ) { return ; }
            // /home/alex/Desktop/Go.g:419:2: ( expressionList ( '=' | ':=' ) 'range' expression )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:419:5: expressionList ( '=' | ':=' ) 'range' expression
            {
            dbg.location(419,5);
            pushFollow(FOLLOW_expressionList_in_rangeClause3694);
            expressionList();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(419,20);
            if ( input.LA(1)==58||input.LA(1)==61 ) {
                input.consume();
                state.errorRecovery=false;state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                dbg.recognitionException(mse);
                throw mse;
            }

            dbg.location(419,35);
            match(input,72,FOLLOW_72_in_rangeClause3706); if (state.failed) return ;
            dbg.location(419,43);
            pushFollow(FOLLOW_expression_in_rangeClause3708);
            expression();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 94, rangeClause_StartIndex); }
        }
        dbg.location(419, 54);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "rangeClause");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "rangeClause"


    // $ANTLR start "goStmt"
    // /home/alex/Desktop/Go.g:421:1: goStmt : 'go' expression ;
    public final void goStmt() throws RecognitionException {
        int goStmt_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "goStmt");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(421, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 95) ) { return ; }
            // /home/alex/Desktop/Go.g:422:2: ( 'go' expression )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:422:5: 'go' expression
            {
            dbg.location(422,5);
            match(input,73,FOLLOW_73_in_goStmt3721); if (state.failed) return ;
            dbg.location(422,10);
            pushFollow(FOLLOW_expression_in_goStmt3723);
            expression();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 95, goStmt_StartIndex); }
        }
        dbg.location(422, 21);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "goStmt");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "goStmt"


    // $ANTLR start "selectStmt"
    // /home/alex/Desktop/Go.g:424:1: selectStmt : 'select' '{' ( commClause )* '}' ;
    public final void selectStmt() throws RecognitionException {
        int selectStmt_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "selectStmt");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(424, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 96) ) { return ; }
            // /home/alex/Desktop/Go.g:425:2: ( 'select' '{' ( commClause )* '}' )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:425:5: 'select' '{' ( commClause )* '}'
            {
            dbg.location(425,5);
            match(input,74,FOLLOW_74_in_selectStmt3735); if (state.failed) return ;
            dbg.location(425,14);
            match(input,47,FOLLOW_47_in_selectStmt3737); if (state.failed) return ;
            dbg.location(425,18);
            // /home/alex/Desktop/Go.g:425:18: ( commClause )*
            try { dbg.enterSubRule(75);

            loop75:
            do {
                int alt75=2;
                try { dbg.enterDecision(75);

                int LA75_0 = input.LA(1);

                if ( ((LA75_0>=69 && LA75_0<=70)) ) {
                    alt75=1;
                }


                } finally {dbg.exitDecision(75);}

                switch (alt75) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // /home/alex/Desktop/Go.g:425:20: commClause
            	    {
            	    dbg.location(425,20);
            	    pushFollow(FOLLOW_commClause_in_selectStmt3741);
            	    commClause();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop75;
                }
            } while (true);
            } finally {dbg.exitSubRule(75);}

            dbg.location(425,34);
            match(input,49,FOLLOW_49_in_selectStmt3746); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 96, selectStmt_StartIndex); }
        }
        dbg.location(425, 38);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "selectStmt");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "selectStmt"


    // $ANTLR start "commClause"
    // /home/alex/Desktop/Go.g:426:1: commClause : commCase ':' ( statement ';' )? ;
    public final void commClause() throws RecognitionException {
        int commClause_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "commClause");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(426, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 97) ) { return ; }
            // /home/alex/Desktop/Go.g:427:2: ( commCase ':' ( statement ';' )? )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:427:5: commCase ':' ( statement ';' )?
            {
            dbg.location(427,5);
            pushFollow(FOLLOW_commCase_in_commClause3757);
            commCase();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(427,14);
            match(input,63,FOLLOW_63_in_commClause3759); if (state.failed) return ;
            dbg.location(427,18);
            // /home/alex/Desktop/Go.g:427:18: ( statement ';' )?
            int alt76=2;
            try { dbg.enterSubRule(76);
            try { dbg.enterDecision(76);

            int LA76_0 = input.LA(1);

            if ( (LA76_0==Identifier||LA76_0==Int_lit||(LA76_0>=Float_lit && LA76_0<=Imaginary_lit)||LA76_0==Char_lit||LA76_0==String_lit||LA76_0==Unary_op||LA76_0==42||LA76_0==44||(LA76_0>=46 && LA76_0<=48)||LA76_0==51||LA76_0==55||LA76_0==57||(LA76_0>=59 && LA76_0<=60)||LA76_0==66||LA76_0==68||LA76_0==71||(LA76_0>=73 && LA76_0<=80)) ) {
                alt76=1;
            }
            } finally {dbg.exitDecision(76);}

            switch (alt76) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:427:20: statement ';'
                    {
                    dbg.location(427,20);
                    pushFollow(FOLLOW_statement_in_commClause3763);
                    statement();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(427,30);
                    match(input,48,FOLLOW_48_in_commClause3765); if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(76);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 97, commClause_StartIndex); }
        }
        dbg.location(427, 37);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "commClause");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "commClause"


    // $ANTLR start "commCase"
    // /home/alex/Desktop/Go.g:428:1: commCase : ( 'case' ( sendExpr | recvExpr ) | 'default' );
    public final void commCase() throws RecognitionException {
        int commCase_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "commCase");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(428, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 98) ) { return ; }
            // /home/alex/Desktop/Go.g:429:2: ( 'case' ( sendExpr | recvExpr ) | 'default' )
            int alt78=2;
            try { dbg.enterDecision(78);

            int LA78_0 = input.LA(1);

            if ( (LA78_0==69) ) {
                alt78=1;
            }
            else if ( (LA78_0==70) ) {
                alt78=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 78, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(78);}

            switch (alt78) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:429:5: 'case' ( sendExpr | recvExpr )
                    {
                    dbg.location(429,5);
                    match(input,69,FOLLOW_69_in_commCase3779); if (state.failed) return ;
                    dbg.location(429,12);
                    // /home/alex/Desktop/Go.g:429:12: ( sendExpr | recvExpr )
                    int alt77=2;
                    try { dbg.enterSubRule(77);
                    try { dbg.enterDecision(77);

                    try {
                        isCyclicDecision = true;
                        alt77 = dfa77.predict(input);
                    }
                    catch (NoViableAltException nvae) {
                        dbg.recognitionException(nvae);
                        throw nvae;
                    }
                    } finally {dbg.exitDecision(77);}

                    switch (alt77) {
                        case 1 :
                            dbg.enterAlt(1);

                            // /home/alex/Desktop/Go.g:429:14: sendExpr
                            {
                            dbg.location(429,14);
                            pushFollow(FOLLOW_sendExpr_in_commCase3783);
                            sendExpr();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;
                        case 2 :
                            dbg.enterAlt(2);

                            // /home/alex/Desktop/Go.g:429:25: recvExpr
                            {
                            dbg.location(429,25);
                            pushFollow(FOLLOW_recvExpr_in_commCase3787);
                            recvExpr();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(77);}


                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // /home/alex/Desktop/Go.g:429:37: 'default'
                    {
                    dbg.location(429,37);
                    match(input,70,FOLLOW_70_in_commCase3792); if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 98, commCase_StartIndex); }
        }
        dbg.location(429, 47);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "commCase");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "commCase"


    // $ANTLR start "sendExpr"
    // /home/alex/Desktop/Go.g:430:1: sendExpr : expression '<-' expression ;
    public final void sendExpr() throws RecognitionException {
        int sendExpr_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "sendExpr");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(430, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 99) ) { return ; }
            // /home/alex/Desktop/Go.g:431:2: ( expression '<-' expression )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:431:5: expression '<-' expression
            {
            dbg.location(431,5);
            pushFollow(FOLLOW_expression_in_sendExpr3803);
            expression();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(431,16);
            match(input,Com_op,FOLLOW_Com_op_in_sendExpr3805); if (state.failed) return ;
            dbg.location(431,21);
            pushFollow(FOLLOW_expression_in_sendExpr3807);
            expression();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 99, sendExpr_StartIndex); }
        }
        dbg.location(431, 32);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "sendExpr");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "sendExpr"


    // $ANTLR start "recvExpr"
    // /home/alex/Desktop/Go.g:432:1: recvExpr : ( expression ( '=' | ':=' ) )? '<-' expression ;
    public final void recvExpr() throws RecognitionException {
        int recvExpr_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "recvExpr");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(432, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 100) ) { return ; }
            // /home/alex/Desktop/Go.g:433:2: ( ( expression ( '=' | ':=' ) )? '<-' expression )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:433:5: ( expression ( '=' | ':=' ) )? '<-' expression
            {
            dbg.location(433,5);
            // /home/alex/Desktop/Go.g:433:5: ( expression ( '=' | ':=' ) )?
            int alt79=2;
            try { dbg.enterSubRule(79);
            try { dbg.enterDecision(79);

            int LA79_0 = input.LA(1);

            if ( (LA79_0==Identifier||LA79_0==Int_lit||(LA79_0>=Float_lit && LA79_0<=Imaginary_lit)||LA79_0==Char_lit||LA79_0==String_lit||LA79_0==Unary_op||LA79_0==42||LA79_0==44||LA79_0==46||LA79_0==51||LA79_0==55) ) {
                alt79=1;
            }
            } finally {dbg.exitDecision(79);}

            switch (alt79) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:433:7: expression ( '=' | ':=' )
                    {
                    dbg.location(433,7);
                    pushFollow(FOLLOW_expression_in_recvExpr3820);
                    expression();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(433,18);
                    if ( input.LA(1)==58||input.LA(1)==61 ) {
                        input.consume();
                        state.errorRecovery=false;state.failed=false;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return ;}
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        dbg.recognitionException(mse);
                        throw mse;
                    }


                    }
                    break;

            }
            } finally {dbg.exitSubRule(79);}

            dbg.location(433,36);
            match(input,Com_op,FOLLOW_Com_op_in_recvExpr3835); if (state.failed) return ;
            dbg.location(433,41);
            pushFollow(FOLLOW_expression_in_recvExpr3837);
            expression();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 100, recvExpr_StartIndex); }
        }
        dbg.location(433, 52);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "recvExpr");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "recvExpr"


    // $ANTLR start "returnStmt"
    // /home/alex/Desktop/Go.g:435:1: returnStmt : 'return' ( expressionList )? ;
    public final void returnStmt() throws RecognitionException {
        int returnStmt_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "returnStmt");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(435, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 101) ) { return ; }
            // /home/alex/Desktop/Go.g:436:2: ( 'return' ( expressionList )? )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:436:4: 'return' ( expressionList )?
            {
            dbg.location(436,4);
            match(input,75,FOLLOW_75_in_returnStmt3848); if (state.failed) return ;
            dbg.location(436,13);
            // /home/alex/Desktop/Go.g:436:13: ( expressionList )?
            int alt80=2;
            try { dbg.enterSubRule(80);
            try { dbg.enterDecision(80);

            int LA80_0 = input.LA(1);

            if ( (LA80_0==Identifier||LA80_0==Int_lit||(LA80_0>=Float_lit && LA80_0<=Imaginary_lit)||LA80_0==Char_lit||LA80_0==String_lit||LA80_0==Unary_op||LA80_0==42||LA80_0==44||LA80_0==46||LA80_0==51||LA80_0==55) ) {
                alt80=1;
            }
            } finally {dbg.exitDecision(80);}

            switch (alt80) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:436:15: expressionList
                    {
                    dbg.location(436,15);
                    pushFollow(FOLLOW_expressionList_in_returnStmt3852);
                    expressionList();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(80);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 101, returnStmt_StartIndex); }
        }
        dbg.location(436, 33);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "returnStmt");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "returnStmt"


    // $ANTLR start "breakStmt"
    // /home/alex/Desktop/Go.g:438:1: breakStmt : 'break' ( label )? ;
    public final void breakStmt() throws RecognitionException {
        int breakStmt_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "breakStmt");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(438, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 102) ) { return ; }
            // /home/alex/Desktop/Go.g:439:2: ( 'break' ( label )? )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:439:5: 'break' ( label )?
            {
            dbg.location(439,5);
            match(input,76,FOLLOW_76_in_breakStmt3867); if (state.failed) return ;
            dbg.location(439,13);
            // /home/alex/Desktop/Go.g:439:13: ( label )?
            int alt81=2;
            try { dbg.enterSubRule(81);
            try { dbg.enterDecision(81);

            int LA81_0 = input.LA(1);

            if ( (LA81_0==Identifier) ) {
                alt81=1;
            }
            } finally {dbg.exitDecision(81);}

            switch (alt81) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:439:15: label
                    {
                    dbg.location(439,15);
                    pushFollow(FOLLOW_label_in_breakStmt3871);
                    label();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(81);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 102, breakStmt_StartIndex); }
        }
        dbg.location(439, 24);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "breakStmt");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "breakStmt"


    // $ANTLR start "continueStmt"
    // /home/alex/Desktop/Go.g:441:1: continueStmt : 'continue' ( label )? ;
    public final void continueStmt() throws RecognitionException {
        int continueStmt_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "continueStmt");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(441, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 103) ) { return ; }
            // /home/alex/Desktop/Go.g:442:2: ( 'continue' ( label )? )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:442:5: 'continue' ( label )?
            {
            dbg.location(442,5);
            match(input,77,FOLLOW_77_in_continueStmt3886); if (state.failed) return ;
            dbg.location(442,16);
            // /home/alex/Desktop/Go.g:442:16: ( label )?
            int alt82=2;
            try { dbg.enterSubRule(82);
            try { dbg.enterDecision(82);

            int LA82_0 = input.LA(1);

            if ( (LA82_0==Identifier) ) {
                alt82=1;
            }
            } finally {dbg.exitDecision(82);}

            switch (alt82) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:442:18: label
                    {
                    dbg.location(442,18);
                    pushFollow(FOLLOW_label_in_continueStmt3890);
                    label();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(82);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 103, continueStmt_StartIndex); }
        }
        dbg.location(442, 27);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "continueStmt");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "continueStmt"


    // $ANTLR start "gotoStmt"
    // /home/alex/Desktop/Go.g:445:1: gotoStmt : 'goto' label ;
    public final void gotoStmt() throws RecognitionException {
        int gotoStmt_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "gotoStmt");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(445, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 104) ) { return ; }
            // /home/alex/Desktop/Go.g:446:2: ( 'goto' label )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:446:4: 'goto' label
            {
            dbg.location(446,4);
            match(input,78,FOLLOW_78_in_gotoStmt3905); if (state.failed) return ;
            dbg.location(446,11);
            pushFollow(FOLLOW_label_in_gotoStmt3907);
            label();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 104, gotoStmt_StartIndex); }
        }
        dbg.location(446, 17);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "gotoStmt");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "gotoStmt"


    // $ANTLR start "fallthroughStmt"
    // /home/alex/Desktop/Go.g:448:1: fallthroughStmt : 'fallthrough' ;
    public final void fallthroughStmt() throws RecognitionException {
        int fallthroughStmt_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "fallthroughStmt");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(448, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 105) ) { return ; }
            // /home/alex/Desktop/Go.g:449:2: ( 'fallthrough' )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:449:5: 'fallthrough'
            {
            dbg.location(449,5);
            match(input,79,FOLLOW_79_in_fallthroughStmt3919); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 105, fallthroughStmt_StartIndex); }
        }
        dbg.location(449, 19);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "fallthroughStmt");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "fallthroughStmt"


    // $ANTLR start "deferStmt"
    // /home/alex/Desktop/Go.g:451:1: deferStmt : 'defer' expression ;
    public final void deferStmt() throws RecognitionException {
        int deferStmt_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "deferStmt");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(451, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 106) ) { return ; }
            // /home/alex/Desktop/Go.g:452:2: ( 'defer' expression )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:452:5: 'defer' expression
            {
            dbg.location(452,5);
            match(input,80,FOLLOW_80_in_deferStmt3931); if (state.failed) return ;
            dbg.location(452,13);
            pushFollow(FOLLOW_expression_in_deferStmt3933);
            expression();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 106, deferStmt_StartIndex); }
        }
        dbg.location(452, 23);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "deferStmt");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "deferStmt"


    // $ANTLR start "builtinCall"
    // /home/alex/Desktop/Go.g:454:1: builtinCall : Identifier '(' ( builtinArgs )? ')' ;
    public final void builtinCall() throws RecognitionException {
        int builtinCall_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "builtinCall");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(454, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 107) ) { return ; }
            // /home/alex/Desktop/Go.g:455:2: ( Identifier '(' ( builtinArgs )? ')' )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:455:5: Identifier '(' ( builtinArgs )? ')'
            {
            dbg.location(455,5);
            match(input,Identifier,FOLLOW_Identifier_in_builtinCall3944); if (state.failed) return ;
            dbg.location(455,16);
            match(input,42,FOLLOW_42_in_builtinCall3946); if (state.failed) return ;
            dbg.location(455,20);
            // /home/alex/Desktop/Go.g:455:20: ( builtinArgs )?
            int alt83=2;
            try { dbg.enterSubRule(83);
            try { dbg.enterDecision(83);

            int LA83_0 = input.LA(1);

            if ( (LA83_0==Identifier||LA83_0==Int_lit||(LA83_0>=Float_lit && LA83_0<=Imaginary_lit)||LA83_0==Char_lit||LA83_0==String_lit||LA83_0==Unary_op||LA83_0==Com_op||LA83_0==42||LA83_0==44||LA83_0==46||(LA83_0>=50 && LA83_0<=51)||(LA83_0>=54 && LA83_0<=56)) ) {
                alt83=1;
            }
            } finally {dbg.exitDecision(83);}

            switch (alt83) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:455:22: builtinArgs
                    {
                    dbg.location(455,22);
                    pushFollow(FOLLOW_builtinArgs_in_builtinCall3950);
                    builtinArgs();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(83);}

            dbg.location(455,37);
            match(input,43,FOLLOW_43_in_builtinCall3955); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 107, builtinCall_StartIndex); }
        }
        dbg.location(455, 41);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "builtinCall");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "builtinCall"


    // $ANTLR start "builtinArgs"
    // /home/alex/Desktop/Go.g:456:1: builtinArgs : ( type ( ',' expressionList )? | expressionList );
    public final void builtinArgs() throws RecognitionException {
        int builtinArgs_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "builtinArgs");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(456, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 108) ) { return ; }
            // /home/alex/Desktop/Go.g:457:2: ( type ( ',' expressionList )? | expressionList )
            int alt85=2;
            try { dbg.enterDecision(85);

            try {
                isCyclicDecision = true;
                alt85 = dfa85.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(85);}

            switch (alt85) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:457:5: type ( ',' expressionList )?
                    {
                    dbg.location(457,5);
                    pushFollow(FOLLOW_type_in_builtinArgs3966);
                    type();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(457,10);
                    // /home/alex/Desktop/Go.g:457:10: ( ',' expressionList )?
                    int alt84=2;
                    try { dbg.enterSubRule(84);
                    try { dbg.enterDecision(84);

                    int LA84_0 = input.LA(1);

                    if ( (LA84_0==52) ) {
                        alt84=1;
                    }
                    } finally {dbg.exitDecision(84);}

                    switch (alt84) {
                        case 1 :
                            dbg.enterAlt(1);

                            // /home/alex/Desktop/Go.g:457:12: ',' expressionList
                            {
                            dbg.location(457,12);
                            match(input,52,FOLLOW_52_in_builtinArgs3970); if (state.failed) return ;
                            dbg.location(457,16);
                            pushFollow(FOLLOW_expressionList_in_builtinArgs3972);
                            expressionList();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(84);}


                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // /home/alex/Desktop/Go.g:457:36: expressionList
                    {
                    dbg.location(457,36);
                    pushFollow(FOLLOW_expressionList_in_builtinArgs3979);
                    expressionList();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 108, builtinArgs_StartIndex); }
        }
        dbg.location(457, 51);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "builtinArgs");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "builtinArgs"


    // $ANTLR start "sourceFile"
    // /home/alex/Desktop/Go.g:459:1: sourceFile : packageClause ';' ( importDecl ';' )* ( topLevelDecl ';' )* ;
    public final void sourceFile() throws RecognitionException {
        int sourceFile_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "sourceFile");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(459, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 109) ) { return ; }
            // /home/alex/Desktop/Go.g:460:2: ( packageClause ';' ( importDecl ';' )* ( topLevelDecl ';' )* )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:460:5: packageClause ';' ( importDecl ';' )* ( topLevelDecl ';' )*
            {
            dbg.location(460,5);
            pushFollow(FOLLOW_packageClause_in_sourceFile3997);
            packageClause();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(460,19);
            match(input,48,FOLLOW_48_in_sourceFile3999); if (state.failed) return ;
            dbg.location(460,23);
            // /home/alex/Desktop/Go.g:460:23: ( importDecl ';' )*
            try { dbg.enterSubRule(86);

            loop86:
            do {
                int alt86=2;
                try { dbg.enterDecision(86);

                int LA86_0 = input.LA(1);

                if ( (LA86_0==82) ) {
                    alt86=1;
                }


                } finally {dbg.exitDecision(86);}

                switch (alt86) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // /home/alex/Desktop/Go.g:460:25: importDecl ';'
            	    {
            	    dbg.location(460,25);
            	    pushFollow(FOLLOW_importDecl_in_sourceFile4003);
            	    importDecl();

            	    state._fsp--;
            	    if (state.failed) return ;
            	    dbg.location(460,36);
            	    match(input,48,FOLLOW_48_in_sourceFile4005); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop86;
                }
            } while (true);
            } finally {dbg.exitSubRule(86);}

            dbg.location(460,43);
            // /home/alex/Desktop/Go.g:460:43: ( topLevelDecl ';' )*
            try { dbg.enterSubRule(87);

            loop87:
            do {
                int alt87=2;
                try { dbg.enterDecision(87);

                int LA87_0 = input.LA(1);

                if ( (LA87_0==51||LA87_0==57||(LA87_0>=59 && LA87_0<=60)) ) {
                    alt87=1;
                }


                } finally {dbg.exitDecision(87);}

                switch (alt87) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // /home/alex/Desktop/Go.g:460:45: topLevelDecl ';'
            	    {
            	    dbg.location(460,45);
            	    pushFollow(FOLLOW_topLevelDecl_in_sourceFile4012);
            	    topLevelDecl();

            	    state._fsp--;
            	    if (state.failed) return ;
            	    dbg.location(460,58);
            	    match(input,48,FOLLOW_48_in_sourceFile4014); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop87;
                }
            } while (true);
            } finally {dbg.exitSubRule(87);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 109, sourceFile_StartIndex); }
        }
        dbg.location(460, 65);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "sourceFile");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "sourceFile"


    // $ANTLR start "packageClause"
    // /home/alex/Desktop/Go.g:462:1: packageClause : 'package' packageName ;
    public final void packageClause() throws RecognitionException {
        int packageClause_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "packageClause");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(462, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 110) ) { return ; }
            // /home/alex/Desktop/Go.g:463:2: ( 'package' packageName )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:463:5: 'package' packageName
            {
            dbg.location(463,5);
            match(input,81,FOLLOW_81_in_packageClause4030); if (state.failed) return ;
            dbg.location(463,15);
            pushFollow(FOLLOW_packageName_in_packageClause4032);
            packageName();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 110, packageClause_StartIndex); }
        }
        dbg.location(463, 27);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "packageClause");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "packageClause"


    // $ANTLR start "packageName"
    // /home/alex/Desktop/Go.g:464:1: packageName : Identifier ;
    public final void packageName() throws RecognitionException {
        int packageName_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "packageName");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(464, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 111) ) { return ; }
            // /home/alex/Desktop/Go.g:465:2: ( Identifier )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:465:5: Identifier
            {
            dbg.location(465,5);
            match(input,Identifier,FOLLOW_Identifier_in_packageName4046); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 111, packageName_StartIndex); }
        }
        dbg.location(465, 16);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "packageName");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "packageName"


    // $ANTLR start "importDecl"
    // /home/alex/Desktop/Go.g:467:1: importDecl : 'import' ( importSpec | '(' ( importSpec ';' )* ')' ) ;
    public final void importDecl() throws RecognitionException {
        int importDecl_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "importDecl");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(467, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 112) ) { return ; }
            // /home/alex/Desktop/Go.g:468:2: ( 'import' ( importSpec | '(' ( importSpec ';' )* ')' ) )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:468:5: 'import' ( importSpec | '(' ( importSpec ';' )* ')' )
            {
            dbg.location(468,5);
            match(input,82,FOLLOW_82_in_importDecl4064); if (state.failed) return ;
            dbg.location(468,14);
            // /home/alex/Desktop/Go.g:468:14: ( importSpec | '(' ( importSpec ';' )* ')' )
            int alt89=2;
            try { dbg.enterSubRule(89);
            try { dbg.enterDecision(89);

            int LA89_0 = input.LA(1);

            if ( (LA89_0==Identifier||LA89_0==String_lit||LA89_0==62) ) {
                alt89=1;
            }
            else if ( (LA89_0==42) ) {
                alt89=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 89, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(89);}

            switch (alt89) {
                case 1 :
                    dbg.enterAlt(1);

                    // /home/alex/Desktop/Go.g:468:16: importSpec
                    {
                    dbg.location(468,16);
                    pushFollow(FOLLOW_importSpec_in_importDecl4068);
                    importSpec();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // /home/alex/Desktop/Go.g:468:29: '(' ( importSpec ';' )* ')'
                    {
                    dbg.location(468,29);
                    match(input,42,FOLLOW_42_in_importDecl4072); if (state.failed) return ;
                    dbg.location(468,33);
                    // /home/alex/Desktop/Go.g:468:33: ( importSpec ';' )*
                    try { dbg.enterSubRule(88);

                    loop88:
                    do {
                        int alt88=2;
                        try { dbg.enterDecision(88);

                        int LA88_0 = input.LA(1);

                        if ( (LA88_0==Identifier||LA88_0==String_lit||LA88_0==62) ) {
                            alt88=1;
                        }


                        } finally {dbg.exitDecision(88);}

                        switch (alt88) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // /home/alex/Desktop/Go.g:468:35: importSpec ';'
                    	    {
                    	    dbg.location(468,35);
                    	    pushFollow(FOLLOW_importSpec_in_importDecl4076);
                    	    importSpec();

                    	    state._fsp--;
                    	    if (state.failed) return ;
                    	    dbg.location(468,46);
                    	    match(input,48,FOLLOW_48_in_importDecl4078); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop88;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(88);}

                    dbg.location(468,53);
                    match(input,43,FOLLOW_43_in_importDecl4083); if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(89);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 112, importDecl_StartIndex); }
        }
        dbg.location(468, 59);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "importDecl");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "importDecl"


    // $ANTLR start "importSpec"
    // /home/alex/Desktop/Go.g:469:1: importSpec : ( '.' | packageName )* importPath ;
    public final void importSpec() throws RecognitionException {
        int importSpec_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "importSpec");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(469, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 113) ) { return ; }
            // /home/alex/Desktop/Go.g:470:2: ( ( '.' | packageName )* importPath )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:470:5: ( '.' | packageName )* importPath
            {
            dbg.location(470,5);
            // /home/alex/Desktop/Go.g:470:5: ( '.' | packageName )*
            try { dbg.enterSubRule(90);

            loop90:
            do {
                int alt90=3;
                try { dbg.enterDecision(90);

                int LA90_0 = input.LA(1);

                if ( (LA90_0==62) ) {
                    alt90=1;
                }
                else if ( (LA90_0==Identifier) ) {
                    alt90=2;
                }


                } finally {dbg.exitDecision(90);}

                switch (alt90) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // /home/alex/Desktop/Go.g:470:7: '.'
            	    {
            	    dbg.location(470,7);
            	    match(input,62,FOLLOW_62_in_importSpec4104); if (state.failed) return ;

            	    }
            	    break;
            	case 2 :
            	    dbg.enterAlt(2);

            	    // /home/alex/Desktop/Go.g:470:13: packageName
            	    {
            	    dbg.location(470,13);
            	    pushFollow(FOLLOW_packageName_in_importSpec4108);
            	    packageName();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop90;
                }
            } while (true);
            } finally {dbg.exitSubRule(90);}

            dbg.location(470,28);
            pushFollow(FOLLOW_importPath_in_importSpec4113);
            importPath();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 113, importSpec_StartIndex); }
        }
        dbg.location(470, 39);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "importSpec");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "importSpec"


    // $ANTLR start "importPath"
    // /home/alex/Desktop/Go.g:471:1: importPath : String_lit ;
    public final void importPath() throws RecognitionException {
        int importPath_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "importPath");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(471, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 114) ) { return ; }
            // /home/alex/Desktop/Go.g:472:2: ( String_lit )
            dbg.enterAlt(1);

            // /home/alex/Desktop/Go.g:472:5: String_lit
            {
            dbg.location(472,5);
            match(input,String_lit,FOLLOW_String_lit_in_importPath4130); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 114, importPath_StartIndex); }
        }
        dbg.location(472, 16);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "importPath");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "importPath"

    // $ANTLR start synpred14_Go
    public final void synpred14_Go_fragment() throws RecognitionException {   
        // /home/alex/Desktop/Go.g:194:18: ( result )
        dbg.enterAlt(1);

        // /home/alex/Desktop/Go.g:194:18: result
        {
        dbg.location(194,18);
        pushFollow(FOLLOW_result_in_synpred14_Go1543);
        result();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred14_Go

    // $ANTLR start synpred15_Go
    public final void synpred15_Go_fragment() throws RecognitionException {   
        // /home/alex/Desktop/Go.g:196:5: ( parameters )
        dbg.enterAlt(1);

        // /home/alex/Desktop/Go.g:196:5: parameters
        {
        dbg.location(196,5);
        pushFollow(FOLLOW_parameters_in_synpred15_Go1565);
        parameters();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred15_Go

    // $ANTLR start synpred19_Go
    public final void synpred19_Go_fragment() throws RecognitionException {   
        // /home/alex/Desktop/Go.g:202:7: ( identifierList )
        dbg.enterAlt(1);

        // /home/alex/Desktop/Go.g:202:7: identifierList
        {
        dbg.location(202,7);
        pushFollow(FOLLOW_identifierList_in_synpred19_Go1635);
        identifierList();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred19_Go

    // $ANTLR start synpred24_Go
    public final void synpred24_Go_fragment() throws RecognitionException {   
        // /home/alex/Desktop/Go.g:219:5: ( channel )
        dbg.enterAlt(1);

        // /home/alex/Desktop/Go.g:219:5: channel
        {
        dbg.location(219,5);
        pushFollow(FOLLOW_channel_in_synpred24_Go1794);
        channel();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred24_Go

    // $ANTLR start synpred25_Go
    public final void synpred25_Go_fragment() throws RecognitionException {   
        // /home/alex/Desktop/Go.g:219:15: ( sendChannel )
        dbg.enterAlt(1);

        // /home/alex/Desktop/Go.g:219:15: sendChannel
        {
        dbg.location(219,15);
        pushFollow(FOLLOW_sendChannel_in_synpred25_Go1798);
        sendChannel();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred25_Go

    // $ANTLR start synpred47_Go
    public final void synpred47_Go_fragment() throws RecognitionException {   
        // /home/alex/Desktop/Go.g:270:5: ( literal )
        dbg.enterAlt(1);

        // /home/alex/Desktop/Go.g:270:5: literal
        {
        dbg.location(270,5);
        pushFollow(FOLLOW_literal_in_synpred47_Go2300);
        literal();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred47_Go

    // $ANTLR start synpred48_Go
    public final void synpred48_Go_fragment() throws RecognitionException {   
        // /home/alex/Desktop/Go.g:270:15: ( qualifiedIdent )
        dbg.enterAlt(1);

        // /home/alex/Desktop/Go.g:270:15: qualifiedIdent
        {
        dbg.location(270,15);
        pushFollow(FOLLOW_qualifiedIdent_in_synpred48_Go2304);
        qualifiedIdent();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred48_Go

    // $ANTLR start synpred49_Go
    public final void synpred49_Go_fragment() throws RecognitionException {   
        // /home/alex/Desktop/Go.g:270:32: ( methodExpr )
        dbg.enterAlt(1);

        // /home/alex/Desktop/Go.g:270:32: methodExpr
        {
        dbg.location(270,32);
        pushFollow(FOLLOW_methodExpr_in_synpred49_Go2308);
        methodExpr();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred49_Go

    // $ANTLR start synpred56_Go
    public final void synpred56_Go_fragment() throws RecognitionException {   
        // /home/alex/Desktop/Go.g:277:7: ( packageName '.' )
        dbg.enterAlt(1);

        // /home/alex/Desktop/Go.g:277:7: packageName '.'
        {
        dbg.location(277,7);
        pushFollow(FOLLOW_packageName_in_synpred56_Go2381);
        packageName();

        state._fsp--;
        if (state.failed) return ;
        dbg.location(277,19);
        match(input,62,FOLLOW_62_in_synpred56_Go2383); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred56_Go

    // $ANTLR start synpred66_Go
    public final void synpred66_Go_fragment() throws RecognitionException {   
        // /home/alex/Desktop/Go.g:287:7: ( key ':' )
        dbg.enterAlt(1);

        // /home/alex/Desktop/Go.g:287:7: key ':'
        {
        dbg.location(287,7);
        pushFollow(FOLLOW_key_in_synpred66_Go2523);
        key();

        state._fsp--;
        if (state.failed) return ;
        dbg.location(287,11);
        match(input,63,FOLLOW_63_in_synpred66_Go2525); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred66_Go

    // $ANTLR start synpred67_Go
    public final void synpred67_Go_fragment() throws RecognitionException {   
        // /home/alex/Desktop/Go.g:289:5: ( fieldName )
        dbg.enterAlt(1);

        // /home/alex/Desktop/Go.g:289:5: fieldName
        {
        dbg.location(289,5);
        pushFollow(FOLLOW_fieldName_in_synpred67_Go2551);
        fieldName();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred67_Go

    // $ANTLR start synpred68_Go
    public final void synpred68_Go_fragment() throws RecognitionException {   
        // /home/alex/Desktop/Go.g:303:3: ( operand )
        dbg.enterAlt(1);

        // /home/alex/Desktop/Go.g:303:3: operand
        {
        dbg.location(303,3);
        pushFollow(FOLLOW_operand_in_synpred68_Go2630);
        operand();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred68_Go

    // $ANTLR start synpred69_Go
    public final void synpred69_Go_fragment() throws RecognitionException {   
        // /home/alex/Desktop/Go.g:303:13: ( conversion )
        dbg.enterAlt(1);

        // /home/alex/Desktop/Go.g:303:13: conversion
        {
        dbg.location(303,13);
        pushFollow(FOLLOW_conversion_in_synpred69_Go2634);
        conversion();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred69_Go

    // $ANTLR start synpred70_Go
    public final void synpred70_Go_fragment() throws RecognitionException {   
        // /home/alex/Desktop/Go.g:303:40: ( selector )
        dbg.enterAlt(1);

        // /home/alex/Desktop/Go.g:303:40: selector
        {
        dbg.location(303,40);
        pushFollow(FOLLOW_selector_in_synpred70_Go2642);
        selector();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred70_Go

    // $ANTLR start synpred71_Go
    public final void synpred71_Go_fragment() throws RecognitionException {   
        // /home/alex/Desktop/Go.g:303:51: ( index )
        dbg.enterAlt(1);

        // /home/alex/Desktop/Go.g:303:51: index
        {
        dbg.location(303,51);
        pushFollow(FOLLOW_index_in_synpred71_Go2646);
        index();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred71_Go

    // $ANTLR start synpred72_Go
    public final void synpred72_Go_fragment() throws RecognitionException {   
        // /home/alex/Desktop/Go.g:303:59: ( slice )
        dbg.enterAlt(1);

        // /home/alex/Desktop/Go.g:303:59: slice
        {
        dbg.location(303,59);
        pushFollow(FOLLOW_slice_in_synpred72_Go2650);
        slice();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred72_Go

    // $ANTLR start synpred73_Go
    public final void synpred73_Go_fragment() throws RecognitionException {   
        // /home/alex/Desktop/Go.g:303:67: ( typeAssertion )
        dbg.enterAlt(1);

        // /home/alex/Desktop/Go.g:303:67: typeAssertion
        {
        dbg.location(303,67);
        pushFollow(FOLLOW_typeAssertion_in_synpred73_Go2654);
        typeAssertion();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred73_Go

    // $ANTLR start synpred96_Go
    public final void synpred96_Go_fragment() throws RecognitionException {   
        // /home/alex/Desktop/Go.g:359:17: ( expressionStmt )
        dbg.enterAlt(1);

        // /home/alex/Desktop/Go.g:359:17: expressionStmt
        {
        dbg.location(359,17);
        pushFollow(FOLLOW_expressionStmt_in_synpred96_Go3193);
        expressionStmt();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred96_Go

    // $ANTLR start synpred97_Go
    public final void synpred97_Go_fragment() throws RecognitionException {   
        // /home/alex/Desktop/Go.g:359:34: ( incDecStmt )
        dbg.enterAlt(1);

        // /home/alex/Desktop/Go.g:359:34: incDecStmt
        {
        dbg.location(359,34);
        pushFollow(FOLLOW_incDecStmt_in_synpred97_Go3197);
        incDecStmt();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred97_Go

    // $ANTLR start synpred98_Go
    public final void synpred98_Go_fragment() throws RecognitionException {   
        // /home/alex/Desktop/Go.g:359:47: ( assignment )
        dbg.enterAlt(1);

        // /home/alex/Desktop/Go.g:359:47: assignment
        {
        dbg.location(359,47);
        pushFollow(FOLLOW_assignment_in_synpred98_Go3201);
        assignment();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred98_Go

    // $ANTLR start synpred100_Go
    public final void synpred100_Go_fragment() throws RecognitionException {   
        // /home/alex/Desktop/Go.g:383:12: ( simpleStmt ';' )
        dbg.enterAlt(1);

        // /home/alex/Desktop/Go.g:383:12: simpleStmt ';'
        {
        dbg.location(383,12);
        pushFollow(FOLLOW_simpleStmt_in_synpred100_Go3341);
        simpleStmt();

        state._fsp--;
        if (state.failed) return ;
        dbg.location(383,23);
        match(input,48,FOLLOW_48_in_synpred100_Go3343); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred100_Go

    // $ANTLR start synpred103_Go
    public final void synpred103_Go_fragment() throws RecognitionException {   
        // /home/alex/Desktop/Go.g:386:5: ( exprSwitchStmt )
        dbg.enterAlt(1);

        // /home/alex/Desktop/Go.g:386:5: exprSwitchStmt
        {
        dbg.location(386,5);
        pushFollow(FOLLOW_exprSwitchStmt_in_synpred103_Go3376);
        exprSwitchStmt();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred103_Go

    // $ANTLR start synpred104_Go
    public final void synpred104_Go_fragment() throws RecognitionException {   
        // /home/alex/Desktop/Go.g:389:16: ( simpleStmt ';' )
        dbg.enterAlt(1);

        // /home/alex/Desktop/Go.g:389:16: simpleStmt ';'
        {
        dbg.location(389,16);
        pushFollow(FOLLOW_simpleStmt_in_synpred104_Go3396);
        simpleStmt();

        state._fsp--;
        if (state.failed) return ;
        dbg.location(389,27);
        match(input,48,FOLLOW_48_in_synpred104_Go3398); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred104_Go

    // $ANTLR start synpred109_Go
    public final void synpred109_Go_fragment() throws RecognitionException {   
        // /home/alex/Desktop/Go.g:396:16: ( simpleStmt ';' )
        dbg.enterAlt(1);

        // /home/alex/Desktop/Go.g:396:16: simpleStmt ';'
        {
        dbg.location(396,16);
        pushFollow(FOLLOW_simpleStmt_in_synpred109_Go3475);
        simpleStmt();

        state._fsp--;
        if (state.failed) return ;
        dbg.location(396,27);
        match(input,48,FOLLOW_48_in_synpred109_Go3477); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred109_Go

    // $ANTLR start synpred115_Go
    public final void synpred115_Go_fragment() throws RecognitionException {   
        // /home/alex/Desktop/Go.g:407:13: ( condition )
        dbg.enterAlt(1);

        // /home/alex/Desktop/Go.g:407:13: condition
        {
        dbg.location(407,13);
        pushFollow(FOLLOW_condition_in_synpred115_Go3601);
        condition();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred115_Go

    // $ANTLR start synpred116_Go
    public final void synpred116_Go_fragment() throws RecognitionException {   
        // /home/alex/Desktop/Go.g:407:25: ( forClause )
        dbg.enterAlt(1);

        // /home/alex/Desktop/Go.g:407:25: forClause
        {
        dbg.location(407,25);
        pushFollow(FOLLOW_forClause_in_synpred116_Go3605);
        forClause();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred116_Go

    // $ANTLR start synpred117_Go
    public final void synpred117_Go_fragment() throws RecognitionException {   
        // /home/alex/Desktop/Go.g:407:37: ( rangeClause )
        dbg.enterAlt(1);

        // /home/alex/Desktop/Go.g:407:37: rangeClause
        {
        dbg.location(407,37);
        pushFollow(FOLLOW_rangeClause_in_synpred117_Go3609);
        rangeClause();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred117_Go

    // $ANTLR start synpred118_Go
    public final void synpred118_Go_fragment() throws RecognitionException {   
        // /home/alex/Desktop/Go.g:412:7: ( initStmt )
        dbg.enterAlt(1);

        // /home/alex/Desktop/Go.g:412:7: initStmt
        {
        dbg.location(412,7);
        pushFollow(FOLLOW_initStmt_in_synpred118_Go3639);
        initStmt();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred118_Go

    // $ANTLR start synpred120_Go
    public final void synpred120_Go_fragment() throws RecognitionException {   
        // /home/alex/Desktop/Go.g:412:44: ( postStmt )
        dbg.enterAlt(1);

        // /home/alex/Desktop/Go.g:412:44: postStmt
        {
        dbg.location(412,44);
        pushFollow(FOLLOW_postStmt_in_synpred120_Go3657);
        postStmt();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred120_Go

    // $ANTLR start synpred124_Go
    public final void synpred124_Go_fragment() throws RecognitionException {   
        // /home/alex/Desktop/Go.g:429:14: ( sendExpr )
        dbg.enterAlt(1);

        // /home/alex/Desktop/Go.g:429:14: sendExpr
        {
        dbg.location(429,14);
        pushFollow(FOLLOW_sendExpr_in_synpred124_Go3783);
        sendExpr();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred124_Go

    // $ANTLR start synpred133_Go
    public final void synpred133_Go_fragment() throws RecognitionException {   
        // /home/alex/Desktop/Go.g:457:5: ( type ( ',' expressionList )? )
        dbg.enterAlt(1);

        // /home/alex/Desktop/Go.g:457:5: type ( ',' expressionList )?
        {
        dbg.location(457,5);
        pushFollow(FOLLOW_type_in_synpred133_Go3966);
        type();

        state._fsp--;
        if (state.failed) return ;
        dbg.location(457,10);
        // /home/alex/Desktop/Go.g:457:10: ( ',' expressionList )?
        int alt97=2;
        try { dbg.enterSubRule(97);
        try { dbg.enterDecision(97);

        int LA97_0 = input.LA(1);

        if ( (LA97_0==52) ) {
            alt97=1;
        }
        } finally {dbg.exitDecision(97);}

        switch (alt97) {
            case 1 :
                dbg.enterAlt(1);

                // /home/alex/Desktop/Go.g:457:12: ',' expressionList
                {
                dbg.location(457,12);
                match(input,52,FOLLOW_52_in_synpred133_Go3970); if (state.failed) return ;
                dbg.location(457,16);
                pushFollow(FOLLOW_expressionList_in_synpred133_Go3972);
                expressionList();

                state._fsp--;
                if (state.failed) return ;

                }
                break;

        }
        } finally {dbg.exitSubRule(97);}


        }
    }
    // $ANTLR end synpred133_Go

    // Delegated rules

    public final boolean synpred97_Go() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred97_Go_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred103_Go() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred103_Go_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred100_Go() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred100_Go_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred24_Go() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred24_Go_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred73_Go() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred73_Go_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred120_Go() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred120_Go_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred96_Go() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred96_Go_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred117_Go() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred117_Go_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred25_Go() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred25_Go_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred124_Go() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred124_Go_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred66_Go() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred66_Go_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred15_Go() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred15_Go_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred104_Go() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred104_Go_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred56_Go() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred56_Go_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred70_Go() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred70_Go_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred67_Go() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred67_Go_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred14_Go() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred14_Go_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred68_Go() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred68_Go_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred69_Go() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred69_Go_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred115_Go() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred115_Go_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred118_Go() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred118_Go_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred47_Go() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred47_Go_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred48_Go() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred48_Go_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred72_Go() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred72_Go_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred49_Go() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred49_Go_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred98_Go() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred98_Go_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred71_Go() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred71_Go_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred19_Go() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred19_Go_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred133_Go() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred133_Go_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred116_Go() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred116_Go_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred109_Go() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred109_Go_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }


    protected DFA2 dfa2 = new DFA2(this);
    protected DFA7 dfa7 = new DFA7(this);
    protected DFA8 dfa8 = new DFA8(this);
    protected DFA37 dfa37 = new DFA37(this);
    protected DFA44 dfa44 = new DFA44(this);
    protected DFA46 dfa46 = new DFA46(this);
    protected DFA47 dfa47 = new DFA47(this);
    protected DFA54 dfa54 = new DFA54(this);
    protected DFA55 dfa55 = new DFA55(this);
    protected DFA56 dfa56 = new DFA56(this);
    protected DFA60 dfa60 = new DFA60(this);
    protected DFA65 dfa65 = new DFA65(this);
    protected DFA71 dfa71 = new DFA71(this);
    protected DFA77 dfa77 = new DFA77(this);
    protected DFA85 dfa85 = new DFA85(this);
    static final String DFA2_eotS =
        "\12\uffff";
    static final String DFA2_eofS =
        "\12\uffff";
    static final String DFA2_minS =
        "\1\45\1\16\10\uffff";
    static final String DFA2_maxS =
        "\1\70\1\67\10\uffff";
    static final String DFA2_acceptS =
        "\2\uffff\1\2\1\3\1\4\1\5\1\7\1\10\1\6\1\1";
    static final String DFA2_specialS =
        "\12\uffff}>";
    static final String[] DFA2_transitionS = {
            "\1\7\6\uffff\1\1\1\uffff\1\2\3\uffff\1\3\1\4\2\uffff\1\5\1\6"+
            "\1\7",
            "\1\11\3\uffff\1\11\2\uffff\2\11\2\uffff\1\11\7\uffff\1\11\1"+
            "\uffff\1\11\6\uffff\1\11\1\uffff\1\11\1\10\1\11\4\uffff\1\11"+
            "\3\uffff\1\11",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA2_eot = DFA.unpackEncodedString(DFA2_eotS);
    static final short[] DFA2_eof = DFA.unpackEncodedString(DFA2_eofS);
    static final char[] DFA2_min = DFA.unpackEncodedStringToUnsignedChars(DFA2_minS);
    static final char[] DFA2_max = DFA.unpackEncodedStringToUnsignedChars(DFA2_maxS);
    static final short[] DFA2_accept = DFA.unpackEncodedString(DFA2_acceptS);
    static final short[] DFA2_special = DFA.unpackEncodedString(DFA2_specialS);
    static final short[][] DFA2_transition;

    static {
        int numStates = DFA2_transitionS.length;
        DFA2_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA2_transition[i] = DFA.unpackEncodedString(DFA2_transitionS[i]);
        }
    }

    class DFA2 extends DFA {

        public DFA2(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 2;
            this.eot = DFA2_eot;
            this.eof = DFA2_eof;
            this.min = DFA2_min;
            this.max = DFA2_max;
            this.accept = DFA2_accept;
            this.special = DFA2_special;
            this.transition = DFA2_transition;
        }
        public String getDescription() {
            return "163:1: typeLit : ( arrayType | structType | pointerType | functionType | interfaceType | sliceType | mapType | channelType );";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA7_eotS =
        "\24\uffff";
    static final String DFA7_eofS =
        "\1\13\23\uffff";
    static final String DFA7_minS =
        "\1\16\1\0\22\uffff";
    static final String DFA7_maxS =
        "\1\77\1\0\22\uffff";
    static final String DFA7_acceptS =
        "\2\uffff\1\1\10\uffff\1\2\10\uffff";
    static final String DFA7_specialS =
        "\1\uffff\1\0\22\uffff}>";
    static final String[] DFA7_transitionS = {
            "\1\2\22\uffff\1\13\3\uffff\1\2\4\uffff\1\1\1\13\1\2\1\13\1\2"+
            "\2\13\1\uffff\2\2\1\13\1\uffff\3\2\1\uffff\1\13\4\uffff\1\13",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA7_eot = DFA.unpackEncodedString(DFA7_eotS);
    static final short[] DFA7_eof = DFA.unpackEncodedString(DFA7_eofS);
    static final char[] DFA7_min = DFA.unpackEncodedStringToUnsignedChars(DFA7_minS);
    static final char[] DFA7_max = DFA.unpackEncodedStringToUnsignedChars(DFA7_maxS);
    static final short[] DFA7_accept = DFA.unpackEncodedString(DFA7_acceptS);
    static final short[] DFA7_special = DFA.unpackEncodedString(DFA7_specialS);
    static final short[][] DFA7_transition;

    static {
        int numStates = DFA7_transitionS.length;
        DFA7_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA7_transition[i] = DFA.unpackEncodedString(DFA7_transitionS[i]);
        }
    }

    class DFA7 extends DFA {

        public DFA7(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 7;
            this.eot = DFA7_eot;
            this.eof = DFA7_eof;
            this.min = DFA7_min;
            this.max = DFA7_max;
            this.accept = DFA7_accept;
            this.special = DFA7_special;
            this.transition = DFA7_transition;
        }
        public String getDescription() {
            return "194:16: ( result )?";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA7_1 = input.LA(1);

                         
                        int index7_1 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred14_Go()) ) {s = 2;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index7_1);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 7, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA8_eotS =
        "\14\uffff";
    static final String DFA8_eofS =
        "\14\uffff";
    static final String DFA8_minS =
        "\1\16\1\0\12\uffff";
    static final String DFA8_maxS =
        "\1\70\1\0\12\uffff";
    static final String DFA8_acceptS =
        "\2\uffff\1\2\10\uffff\1\1";
    static final String DFA8_specialS =
        "\1\uffff\1\0\12\uffff}>";
    static final String[] DFA8_transitionS = {
            "\1\2\26\uffff\1\2\4\uffff\1\1\1\uffff\1\2\1\uffff\1\2\3\uffff"+
            "\2\2\2\uffff\3\2",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA8_eot = DFA.unpackEncodedString(DFA8_eotS);
    static final short[] DFA8_eof = DFA.unpackEncodedString(DFA8_eofS);
    static final char[] DFA8_min = DFA.unpackEncodedStringToUnsignedChars(DFA8_minS);
    static final char[] DFA8_max = DFA.unpackEncodedStringToUnsignedChars(DFA8_maxS);
    static final short[] DFA8_accept = DFA.unpackEncodedString(DFA8_acceptS);
    static final short[] DFA8_special = DFA.unpackEncodedString(DFA8_specialS);
    static final short[][] DFA8_transition;

    static {
        int numStates = DFA8_transitionS.length;
        DFA8_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA8_transition[i] = DFA.unpackEncodedString(DFA8_transitionS[i]);
        }
    }

    class DFA8 extends DFA {

        public DFA8(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 8;
            this.eot = DFA8_eot;
            this.eof = DFA8_eof;
            this.min = DFA8_min;
            this.max = DFA8_max;
            this.accept = DFA8_accept;
            this.special = DFA8_special;
            this.transition = DFA8_transition;
        }
        public String getDescription() {
            return "195:1: result : ( parameters | type );";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA8_1 = input.LA(1);

                         
                        int index8_1 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred15_Go()) ) {s = 11;}

                        else if ( (true) ) {s = 2;}

                         
                        input.seek(index8_1);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 8, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA37_eotS =
        "\13\uffff";
    static final String DFA37_eofS =
        "\13\uffff";
    static final String DFA37_minS =
        "\1\16\4\uffff\2\0\4\uffff";
    static final String DFA37_maxS =
        "\1\67\4\uffff\2\0\4\uffff";
    static final String DFA37_acceptS =
        "\1\uffff\1\1\6\uffff\1\2\1\3\1\4";
    static final String DFA37_specialS =
        "\5\uffff\1\0\1\1\4\uffff}>";
    static final String[] DFA37_transitionS = {
            "\1\5\3\uffff\1\1\2\uffff\2\1\2\uffff\1\1\7\uffff\1\1\10\uffff"+
            "\1\6\1\uffff\1\1\1\uffff\1\1\4\uffff\1\1\3\uffff\1\1",
            "",
            "",
            "",
            "",
            "\1\uffff",
            "\1\uffff",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA37_eot = DFA.unpackEncodedString(DFA37_eotS);
    static final short[] DFA37_eof = DFA.unpackEncodedString(DFA37_eofS);
    static final char[] DFA37_min = DFA.unpackEncodedStringToUnsignedChars(DFA37_minS);
    static final char[] DFA37_max = DFA.unpackEncodedStringToUnsignedChars(DFA37_maxS);
    static final short[] DFA37_accept = DFA.unpackEncodedString(DFA37_acceptS);
    static final short[] DFA37_special = DFA.unpackEncodedString(DFA37_specialS);
    static final short[][] DFA37_transition;

    static {
        int numStates = DFA37_transitionS.length;
        DFA37_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA37_transition[i] = DFA.unpackEncodedString(DFA37_transitionS[i]);
        }
    }

    class DFA37 extends DFA {

        public DFA37(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 37;
            this.eot = DFA37_eot;
            this.eof = DFA37_eof;
            this.min = DFA37_min;
            this.max = DFA37_max;
            this.accept = DFA37_accept;
            this.special = DFA37_special;
            this.transition = DFA37_transition;
        }
        public String getDescription() {
            return "269:1: operand : ( literal | qualifiedIdent | methodExpr | '(' expression ')' );";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA37_5 = input.LA(1);

                         
                        int index37_5 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred47_Go()) ) {s = 1;}

                        else if ( (synpred48_Go()) ) {s = 8;}

                        else if ( (synpred49_Go()) ) {s = 9;}

                         
                        input.seek(index37_5);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA37_6 = input.LA(1);

                         
                        int index37_6 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred47_Go()) ) {s = 1;}

                        else if ( (synpred49_Go()) ) {s = 9;}

                        else if ( (true) ) {s = 10;}

                         
                        input.seek(index37_6);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 37, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA44_eotS =
        "\13\uffff";
    static final String DFA44_eofS =
        "\13\uffff";
    static final String DFA44_minS =
        "\1\16\10\0\2\uffff";
    static final String DFA44_maxS =
        "\1\67\10\0\2\uffff";
    static final String DFA44_acceptS =
        "\11\uffff\1\1\1\2";
    static final String DFA44_specialS =
        "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\2\uffff}>";
    static final String[] DFA44_transitionS = {
            "\1\1\3\uffff\1\2\2\uffff\2\2\2\uffff\1\2\7\uffff\1\2\1\uffff"+
            "\1\10\6\uffff\1\6\1\uffff\1\4\1\uffff\1\3\4\uffff\1\7\3\uffff"+
            "\1\5",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "",
            ""
    };

    static final short[] DFA44_eot = DFA.unpackEncodedString(DFA44_eotS);
    static final short[] DFA44_eof = DFA.unpackEncodedString(DFA44_eofS);
    static final char[] DFA44_min = DFA.unpackEncodedStringToUnsignedChars(DFA44_minS);
    static final char[] DFA44_max = DFA.unpackEncodedStringToUnsignedChars(DFA44_maxS);
    static final short[] DFA44_accept = DFA.unpackEncodedString(DFA44_acceptS);
    static final short[] DFA44_special = DFA.unpackEncodedString(DFA44_specialS);
    static final short[][] DFA44_transition;

    static {
        int numStates = DFA44_transitionS.length;
        DFA44_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA44_transition[i] = DFA.unpackEncodedString(DFA44_transitionS[i]);
        }
    }

    class DFA44 extends DFA {

        public DFA44(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 44;
            this.eot = DFA44_eot;
            this.eof = DFA44_eof;
            this.min = DFA44_min;
            this.max = DFA44_max;
            this.accept = DFA44_accept;
            this.special = DFA44_special;
            this.transition = DFA44_transition;
        }
        public String getDescription() {
            return "287:5: ( key ':' )?";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA44_1 = input.LA(1);

                         
                        int index44_1 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred66_Go()) ) {s = 9;}

                        else if ( (true) ) {s = 10;}

                         
                        input.seek(index44_1);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA44_2 = input.LA(1);

                         
                        int index44_2 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred66_Go()) ) {s = 9;}

                        else if ( (true) ) {s = 10;}

                         
                        input.seek(index44_2);
                        if ( s>=0 ) return s;
                        break;
                    case 2 : 
                        int LA44_3 = input.LA(1);

                         
                        int index44_3 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred66_Go()) ) {s = 9;}

                        else if ( (true) ) {s = 10;}

                         
                        input.seek(index44_3);
                        if ( s>=0 ) return s;
                        break;
                    case 3 : 
                        int LA44_4 = input.LA(1);

                         
                        int index44_4 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred66_Go()) ) {s = 9;}

                        else if ( (true) ) {s = 10;}

                         
                        input.seek(index44_4);
                        if ( s>=0 ) return s;
                        break;
                    case 4 : 
                        int LA44_5 = input.LA(1);

                         
                        int index44_5 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred66_Go()) ) {s = 9;}

                        else if ( (true) ) {s = 10;}

                         
                        input.seek(index44_5);
                        if ( s>=0 ) return s;
                        break;
                    case 5 : 
                        int LA44_6 = input.LA(1);

                         
                        int index44_6 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred66_Go()) ) {s = 9;}

                        else if ( (true) ) {s = 10;}

                         
                        input.seek(index44_6);
                        if ( s>=0 ) return s;
                        break;
                    case 6 : 
                        int LA44_7 = input.LA(1);

                         
                        int index44_7 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred66_Go()) ) {s = 9;}

                        else if ( (true) ) {s = 10;}

                         
                        input.seek(index44_7);
                        if ( s>=0 ) return s;
                        break;
                    case 7 : 
                        int LA44_8 = input.LA(1);

                         
                        int index44_8 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred66_Go()) ) {s = 9;}

                        else if ( (true) ) {s = 10;}

                         
                        input.seek(index44_8);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 44, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA46_eotS =
        "\12\uffff";
    static final String DFA46_eofS =
        "\12\uffff";
    static final String DFA46_minS =
        "\1\16\1\uffff\5\0\3\uffff";
    static final String DFA46_maxS =
        "\1\67\1\uffff\5\0\3\uffff";
    static final String DFA46_acceptS =
        "\1\uffff\1\1\6\uffff\1\2\1\3";
    static final String DFA46_specialS =
        "\2\uffff\1\0\1\1\1\2\1\3\1\4\3\uffff}>";
    static final String[] DFA46_transitionS = {
            "\1\5\3\uffff\1\1\2\uffff\2\1\2\uffff\1\1\7\uffff\1\1\10\uffff"+
            "\1\6\1\uffff\1\3\1\uffff\1\2\4\uffff\1\1\3\uffff\1\4",
            "",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "",
            "",
            ""
    };

    static final short[] DFA46_eot = DFA.unpackEncodedString(DFA46_eotS);
    static final short[] DFA46_eof = DFA.unpackEncodedString(DFA46_eofS);
    static final char[] DFA46_min = DFA.unpackEncodedStringToUnsignedChars(DFA46_minS);
    static final char[] DFA46_max = DFA.unpackEncodedStringToUnsignedChars(DFA46_maxS);
    static final short[] DFA46_accept = DFA.unpackEncodedString(DFA46_acceptS);
    static final short[] DFA46_special = DFA.unpackEncodedString(DFA46_specialS);
    static final short[][] DFA46_transition;

    static {
        int numStates = DFA46_transitionS.length;
        DFA46_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA46_transition[i] = DFA.unpackEncodedString(DFA46_transitionS[i]);
        }
    }

    class DFA46 extends DFA {

        public DFA46(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 46;
            this.eot = DFA46_eot;
            this.eof = DFA46_eof;
            this.min = DFA46_min;
            this.max = DFA46_max;
            this.accept = DFA46_accept;
            this.special = DFA46_special;
            this.transition = DFA46_transition;
        }
        public String getDescription() {
            return "303:2: ( operand | conversion | builtinCall )";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA46_2 = input.LA(1);

                         
                        int index46_2 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred68_Go()) ) {s = 1;}

                        else if ( (synpred69_Go()) ) {s = 8;}

                         
                        input.seek(index46_2);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA46_3 = input.LA(1);

                         
                        int index46_3 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred68_Go()) ) {s = 1;}

                        else if ( (synpred69_Go()) ) {s = 8;}

                         
                        input.seek(index46_3);
                        if ( s>=0 ) return s;
                        break;
                    case 2 : 
                        int LA46_4 = input.LA(1);

                         
                        int index46_4 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred68_Go()) ) {s = 1;}

                        else if ( (synpred69_Go()) ) {s = 8;}

                         
                        input.seek(index46_4);
                        if ( s>=0 ) return s;
                        break;
                    case 3 : 
                        int LA46_5 = input.LA(1);

                         
                        int index46_5 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred68_Go()) ) {s = 1;}

                        else if ( (synpred69_Go()) ) {s = 8;}

                        else if ( (true) ) {s = 9;}

                         
                        input.seek(index46_5);
                        if ( s>=0 ) return s;
                        break;
                    case 4 : 
                        int LA46_6 = input.LA(1);

                         
                        int index46_6 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred68_Go()) ) {s = 1;}

                        else if ( (synpred69_Go()) ) {s = 8;}

                         
                        input.seek(index46_6);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 46, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA47_eotS =
        "\25\uffff";
    static final String DFA47_eofS =
        "\1\1\24\uffff";
    static final String DFA47_minS =
        "\1\42\15\uffff\2\0\5\uffff";
    static final String DFA47_maxS =
        "\1\101\15\uffff\2\0\5\uffff";
    static final String DFA47_acceptS =
        "\1\uffff\1\6\16\uffff\1\5\1\1\1\4\1\2\1\3";
    static final String DFA47_specialS =
        "\16\uffff\1\0\1\1\5\uffff}>";
    static final String[] DFA47_transitionS = {
            "\1\1\2\uffff\1\1\3\uffff\1\1\1\20\1\1\1\17\1\1\1\uffff\3\1\2"+
            "\uffff\1\1\5\uffff\1\1\2\uffff\1\1\1\16\3\1",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\uffff",
            "\1\uffff",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA47_eot = DFA.unpackEncodedString(DFA47_eotS);
    static final short[] DFA47_eof = DFA.unpackEncodedString(DFA47_eofS);
    static final char[] DFA47_min = DFA.unpackEncodedStringToUnsignedChars(DFA47_minS);
    static final char[] DFA47_max = DFA.unpackEncodedStringToUnsignedChars(DFA47_maxS);
    static final short[] DFA47_accept = DFA.unpackEncodedString(DFA47_acceptS);
    static final short[] DFA47_special = DFA.unpackEncodedString(DFA47_specialS);
    static final short[][] DFA47_transition;

    static {
        int numStates = DFA47_transitionS.length;
        DFA47_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA47_transition[i] = DFA.unpackEncodedString(DFA47_transitionS[i]);
        }
    }

    class DFA47 extends DFA {

        public DFA47(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 47;
            this.eot = DFA47_eot;
            this.eof = DFA47_eof;
            this.min = DFA47_min;
            this.max = DFA47_max;
            this.accept = DFA47_accept;
            this.special = DFA47_special;
            this.transition = DFA47_transition;
        }
        public String getDescription() {
            return "()* loopback of 303:39: ( selector | index | slice | typeAssertion | call )*";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA47_14 = input.LA(1);

                         
                        int index47_14 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred70_Go()) ) {s = 17;}

                        else if ( (synpred73_Go()) ) {s = 18;}

                        else if ( (true) ) {s = 1;}

                         
                        input.seek(index47_14);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA47_15 = input.LA(1);

                         
                        int index47_15 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred71_Go()) ) {s = 19;}

                        else if ( (synpred72_Go()) ) {s = 20;}

                         
                        input.seek(index47_15);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 47, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA54_eotS =
        "\21\uffff";
    static final String DFA54_eofS =
        "\1\3\1\uffff\1\3\16\uffff";
    static final String DFA54_minS =
        "\1\16\1\uffff\1\42\16\uffff";
    static final String DFA54_maxS =
        "\1\120\1\uffff\1\101\16\uffff";
    static final String DFA54_acceptS =
        "\1\uffff\1\1\1\uffff\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14"+
        "\1\15\1\16\1\17\1\2";
    static final String DFA54_specialS =
        "\21\uffff}>";
    static final String[] DFA54_transitionS = {
            "\1\2\3\uffff\1\3\2\uffff\2\3\2\uffff\1\3\7\uffff\1\3\1\uffff"+
            "\1\3\6\uffff\1\3\1\uffff\1\3\1\uffff\1\3\1\12\1\3\2\uffff\1"+
            "\3\3\uffff\1\3\1\uffff\1\1\1\uffff\2\1\5\uffff\1\13\1\uffff"+
            "\1\14\2\uffff\1\16\1\uffff\1\4\1\15\1\5\1\6\1\7\1\10\1\11\1"+
            "\17",
            "",
            "\1\3\6\uffff\2\3\1\uffff\1\3\2\uffff\2\3\3\uffff\1\3\10\uffff"+
            "\2\3\1\20\2\3",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA54_eot = DFA.unpackEncodedString(DFA54_eotS);
    static final short[] DFA54_eof = DFA.unpackEncodedString(DFA54_eofS);
    static final char[] DFA54_min = DFA.unpackEncodedStringToUnsignedChars(DFA54_minS);
    static final char[] DFA54_max = DFA.unpackEncodedStringToUnsignedChars(DFA54_maxS);
    static final short[] DFA54_accept = DFA.unpackEncodedString(DFA54_acceptS);
    static final short[] DFA54_special = DFA.unpackEncodedString(DFA54_specialS);
    static final short[][] DFA54_transition;

    static {
        int numStates = DFA54_transitionS.length;
        DFA54_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA54_transition[i] = DFA.unpackEncodedString(DFA54_transitionS[i]);
        }
    }

    class DFA54 extends DFA {

        public DFA54(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 54;
            this.eot = DFA54_eot;
            this.eof = DFA54_eof;
            this.min = DFA54_min;
            this.max = DFA54_max;
            this.accept = DFA54_accept;
            this.special = DFA54_special;
            this.transition = DFA54_transition;
        }
        public String getDescription() {
            return "351:1: statement : ( declaration | labeledStmt | simpleStmt | goStmt | returnStmt | breakStmt | continueStmt | gotoStmt | fallthroughStmt | block | ifStmt | switchStmt | selectStmt | forStmt | deferStmt );";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA55_eotS =
        "\20\uffff";
    static final String DFA55_eofS =
        "\1\1\17\uffff";
    static final String DFA55_minS =
        "\1\16\3\uffff\10\0\4\uffff";
    static final String DFA55_maxS =
        "\1\67\3\uffff\10\0\4\uffff";
    static final String DFA55_acceptS =
        "\1\uffff\1\1\12\uffff\1\2\1\3\1\4\1\5";
    static final String DFA55_specialS =
        "\4\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\4\uffff}>";
    static final String[] DFA55_transitionS = {
            "\1\10\3\uffff\1\4\2\uffff\2\4\2\uffff\1\4\7\uffff\1\4\1\uffff"+
            "\1\13\6\uffff\1\11\1\uffff\1\6\1\uffff\1\5\2\1\2\uffff\1\12"+
            "\3\uffff\1\7",
            "",
            "",
            "",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA55_eot = DFA.unpackEncodedString(DFA55_eotS);
    static final short[] DFA55_eof = DFA.unpackEncodedString(DFA55_eofS);
    static final char[] DFA55_min = DFA.unpackEncodedStringToUnsignedChars(DFA55_minS);
    static final char[] DFA55_max = DFA.unpackEncodedStringToUnsignedChars(DFA55_maxS);
    static final short[] DFA55_accept = DFA.unpackEncodedString(DFA55_acceptS);
    static final short[] DFA55_special = DFA.unpackEncodedString(DFA55_specialS);
    static final short[][] DFA55_transition;

    static {
        int numStates = DFA55_transitionS.length;
        DFA55_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA55_transition[i] = DFA.unpackEncodedString(DFA55_transitionS[i]);
        }
    }

    class DFA55 extends DFA {

        public DFA55(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 55;
            this.eot = DFA55_eot;
            this.eof = DFA55_eof;
            this.min = DFA55_min;
            this.max = DFA55_max;
            this.accept = DFA55_accept;
            this.special = DFA55_special;
            this.transition = DFA55_transition;
        }
        public String getDescription() {
            return "358:1: simpleStmt : ( emptyStmt | expressionStmt | incDecStmt | assignment | shortVarDecl );";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA55_4 = input.LA(1);

                         
                        int index55_4 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred96_Go()) ) {s = 12;}

                        else if ( (synpred97_Go()) ) {s = 13;}

                        else if ( (synpred98_Go()) ) {s = 14;}

                         
                        input.seek(index55_4);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA55_5 = input.LA(1);

                         
                        int index55_5 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred96_Go()) ) {s = 12;}

                        else if ( (synpred97_Go()) ) {s = 13;}

                        else if ( (synpred98_Go()) ) {s = 14;}

                         
                        input.seek(index55_5);
                        if ( s>=0 ) return s;
                        break;
                    case 2 : 
                        int LA55_6 = input.LA(1);

                         
                        int index55_6 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred96_Go()) ) {s = 12;}

                        else if ( (synpred97_Go()) ) {s = 13;}

                        else if ( (synpred98_Go()) ) {s = 14;}

                         
                        input.seek(index55_6);
                        if ( s>=0 ) return s;
                        break;
                    case 3 : 
                        int LA55_7 = input.LA(1);

                         
                        int index55_7 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred96_Go()) ) {s = 12;}

                        else if ( (synpred97_Go()) ) {s = 13;}

                        else if ( (synpred98_Go()) ) {s = 14;}

                         
                        input.seek(index55_7);
                        if ( s>=0 ) return s;
                        break;
                    case 4 : 
                        int LA55_8 = input.LA(1);

                         
                        int index55_8 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred96_Go()) ) {s = 12;}

                        else if ( (synpred97_Go()) ) {s = 13;}

                        else if ( (synpred98_Go()) ) {s = 14;}

                        else if ( (true) ) {s = 15;}

                         
                        input.seek(index55_8);
                        if ( s>=0 ) return s;
                        break;
                    case 5 : 
                        int LA55_9 = input.LA(1);

                         
                        int index55_9 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred96_Go()) ) {s = 12;}

                        else if ( (synpred97_Go()) ) {s = 13;}

                        else if ( (synpred98_Go()) ) {s = 14;}

                         
                        input.seek(index55_9);
                        if ( s>=0 ) return s;
                        break;
                    case 6 : 
                        int LA55_10 = input.LA(1);

                         
                        int index55_10 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred96_Go()) ) {s = 12;}

                        else if ( (synpred97_Go()) ) {s = 13;}

                        else if ( (synpred98_Go()) ) {s = 14;}

                         
                        input.seek(index55_10);
                        if ( s>=0 ) return s;
                        break;
                    case 7 : 
                        int LA55_11 = input.LA(1);

                         
                        int index55_11 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred96_Go()) ) {s = 12;}

                        else if ( (synpred97_Go()) ) {s = 13;}

                        else if ( (synpred98_Go()) ) {s = 14;}

                         
                        input.seek(index55_11);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 55, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA56_eotS =
        "\13\uffff";
    static final String DFA56_eofS =
        "\13\uffff";
    static final String DFA56_minS =
        "\1\16\1\uffff\10\0\1\uffff";
    static final String DFA56_maxS =
        "\1\67\1\uffff\10\0\1\uffff";
    static final String DFA56_acceptS =
        "\1\uffff\1\1\10\uffff\1\2";
    static final String DFA56_specialS =
        "\2\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\uffff}>";
    static final String[] DFA56_transitionS = {
            "\1\6\3\uffff\1\2\2\uffff\2\2\2\uffff\1\2\7\uffff\1\2\1\uffff"+
            "\1\11\6\uffff\1\7\1\uffff\1\4\1\uffff\1\3\1\12\1\1\2\uffff\1"+
            "\10\3\uffff\1\5",
            "",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            ""
    };

    static final short[] DFA56_eot = DFA.unpackEncodedString(DFA56_eotS);
    static final short[] DFA56_eof = DFA.unpackEncodedString(DFA56_eofS);
    static final char[] DFA56_min = DFA.unpackEncodedStringToUnsignedChars(DFA56_minS);
    static final char[] DFA56_max = DFA.unpackEncodedStringToUnsignedChars(DFA56_maxS);
    static final short[] DFA56_accept = DFA.unpackEncodedString(DFA56_acceptS);
    static final short[] DFA56_special = DFA.unpackEncodedString(DFA56_specialS);
    static final short[][] DFA56_transition;

    static {
        int numStates = DFA56_transitionS.length;
        DFA56_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA56_transition[i] = DFA.unpackEncodedString(DFA56_transitionS[i]);
        }
    }

    class DFA56 extends DFA {

        public DFA56(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 56;
            this.eot = DFA56_eot;
            this.eof = DFA56_eof;
            this.min = DFA56_min;
            this.max = DFA56_max;
            this.accept = DFA56_accept;
            this.special = DFA56_special;
            this.transition = DFA56_transition;
        }
        public String getDescription() {
            return "383:10: ( simpleStmt ';' )?";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA56_2 = input.LA(1);

                         
                        int index56_2 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred100_Go()) ) {s = 1;}

                        else if ( (true) ) {s = 10;}

                         
                        input.seek(index56_2);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA56_3 = input.LA(1);

                         
                        int index56_3 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred100_Go()) ) {s = 1;}

                        else if ( (true) ) {s = 10;}

                         
                        input.seek(index56_3);
                        if ( s>=0 ) return s;
                        break;
                    case 2 : 
                        int LA56_4 = input.LA(1);

                         
                        int index56_4 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred100_Go()) ) {s = 1;}

                        else if ( (true) ) {s = 10;}

                         
                        input.seek(index56_4);
                        if ( s>=0 ) return s;
                        break;
                    case 3 : 
                        int LA56_5 = input.LA(1);

                         
                        int index56_5 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred100_Go()) ) {s = 1;}

                        else if ( (true) ) {s = 10;}

                         
                        input.seek(index56_5);
                        if ( s>=0 ) return s;
                        break;
                    case 4 : 
                        int LA56_6 = input.LA(1);

                         
                        int index56_6 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred100_Go()) ) {s = 1;}

                        else if ( (true) ) {s = 10;}

                         
                        input.seek(index56_6);
                        if ( s>=0 ) return s;
                        break;
                    case 5 : 
                        int LA56_7 = input.LA(1);

                         
                        int index56_7 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred100_Go()) ) {s = 1;}

                        else if ( (true) ) {s = 10;}

                         
                        input.seek(index56_7);
                        if ( s>=0 ) return s;
                        break;
                    case 6 : 
                        int LA56_8 = input.LA(1);

                         
                        int index56_8 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred100_Go()) ) {s = 1;}

                        else if ( (true) ) {s = 10;}

                         
                        input.seek(index56_8);
                        if ( s>=0 ) return s;
                        break;
                    case 7 : 
                        int LA56_9 = input.LA(1);

                         
                        int index56_9 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred100_Go()) ) {s = 1;}

                        else if ( (true) ) {s = 10;}

                         
                        input.seek(index56_9);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 56, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA60_eotS =
        "\13\uffff";
    static final String DFA60_eofS =
        "\13\uffff";
    static final String DFA60_minS =
        "\1\16\1\uffff\10\0\1\uffff";
    static final String DFA60_maxS =
        "\1\67\1\uffff\10\0\1\uffff";
    static final String DFA60_acceptS =
        "\1\uffff\1\1\10\uffff\1\2";
    static final String DFA60_specialS =
        "\2\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\uffff}>";
    static final String[] DFA60_transitionS = {
            "\1\6\3\uffff\1\2\2\uffff\2\2\2\uffff\1\2\7\uffff\1\2\1\uffff"+
            "\1\11\6\uffff\1\7\1\uffff\1\4\1\uffff\1\3\1\12\1\1\2\uffff\1"+
            "\10\3\uffff\1\5",
            "",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            ""
    };

    static final short[] DFA60_eot = DFA.unpackEncodedString(DFA60_eotS);
    static final short[] DFA60_eof = DFA.unpackEncodedString(DFA60_eofS);
    static final char[] DFA60_min = DFA.unpackEncodedStringToUnsignedChars(DFA60_minS);
    static final char[] DFA60_max = DFA.unpackEncodedStringToUnsignedChars(DFA60_maxS);
    static final short[] DFA60_accept = DFA.unpackEncodedString(DFA60_acceptS);
    static final short[] DFA60_special = DFA.unpackEncodedString(DFA60_specialS);
    static final short[][] DFA60_transition;

    static {
        int numStates = DFA60_transitionS.length;
        DFA60_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA60_transition[i] = DFA.unpackEncodedString(DFA60_transitionS[i]);
        }
    }

    class DFA60 extends DFA {

        public DFA60(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 60;
            this.eot = DFA60_eot;
            this.eof = DFA60_eof;
            this.min = DFA60_min;
            this.max = DFA60_max;
            this.accept = DFA60_accept;
            this.special = DFA60_special;
            this.transition = DFA60_transition;
        }
        public String getDescription() {
            return "389:14: ( simpleStmt ';' )?";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA60_2 = input.LA(1);

                         
                        int index60_2 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred104_Go()) ) {s = 1;}

                        else if ( (true) ) {s = 10;}

                         
                        input.seek(index60_2);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA60_3 = input.LA(1);

                         
                        int index60_3 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred104_Go()) ) {s = 1;}

                        else if ( (true) ) {s = 10;}

                         
                        input.seek(index60_3);
                        if ( s>=0 ) return s;
                        break;
                    case 2 : 
                        int LA60_4 = input.LA(1);

                         
                        int index60_4 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred104_Go()) ) {s = 1;}

                        else if ( (true) ) {s = 10;}

                         
                        input.seek(index60_4);
                        if ( s>=0 ) return s;
                        break;
                    case 3 : 
                        int LA60_5 = input.LA(1);

                         
                        int index60_5 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred104_Go()) ) {s = 1;}

                        else if ( (true) ) {s = 10;}

                         
                        input.seek(index60_5);
                        if ( s>=0 ) return s;
                        break;
                    case 4 : 
                        int LA60_6 = input.LA(1);

                         
                        int index60_6 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred104_Go()) ) {s = 1;}

                        else if ( (true) ) {s = 10;}

                         
                        input.seek(index60_6);
                        if ( s>=0 ) return s;
                        break;
                    case 5 : 
                        int LA60_7 = input.LA(1);

                         
                        int index60_7 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred104_Go()) ) {s = 1;}

                        else if ( (true) ) {s = 10;}

                         
                        input.seek(index60_7);
                        if ( s>=0 ) return s;
                        break;
                    case 6 : 
                        int LA60_8 = input.LA(1);

                         
                        int index60_8 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred104_Go()) ) {s = 1;}

                        else if ( (true) ) {s = 10;}

                         
                        input.seek(index60_8);
                        if ( s>=0 ) return s;
                        break;
                    case 7 : 
                        int LA60_9 = input.LA(1);

                         
                        int index60_9 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred104_Go()) ) {s = 1;}

                        else if ( (true) ) {s = 10;}

                         
                        input.seek(index60_9);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 60, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA65_eotS =
        "\13\uffff";
    static final String DFA65_eofS =
        "\13\uffff";
    static final String DFA65_minS =
        "\1\16\1\uffff\7\0\2\uffff";
    static final String DFA65_maxS =
        "\1\67\1\uffff\7\0\2\uffff";
    static final String DFA65_acceptS =
        "\1\uffff\1\1\10\uffff\1\2";
    static final String DFA65_specialS =
        "\2\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\2\uffff}>";
    static final String[] DFA65_transitionS = {
            "\1\6\3\uffff\1\2\2\uffff\2\2\2\uffff\1\2\7\uffff\1\2\1\uffff"+
            "\1\1\6\uffff\1\7\1\uffff\1\4\1\uffff\1\3\1\uffff\1\1\2\uffff"+
            "\1\10\3\uffff\1\5",
            "",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "",
            ""
    };

    static final short[] DFA65_eot = DFA.unpackEncodedString(DFA65_eotS);
    static final short[] DFA65_eof = DFA.unpackEncodedString(DFA65_eofS);
    static final char[] DFA65_min = DFA.unpackEncodedStringToUnsignedChars(DFA65_minS);
    static final char[] DFA65_max = DFA.unpackEncodedStringToUnsignedChars(DFA65_maxS);
    static final short[] DFA65_accept = DFA.unpackEncodedString(DFA65_acceptS);
    static final short[] DFA65_special = DFA.unpackEncodedString(DFA65_specialS);
    static final short[][] DFA65_transition;

    static {
        int numStates = DFA65_transitionS.length;
        DFA65_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA65_transition[i] = DFA.unpackEncodedString(DFA65_transitionS[i]);
        }
    }

    class DFA65 extends DFA {

        public DFA65(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 65;
            this.eot = DFA65_eot;
            this.eof = DFA65_eof;
            this.min = DFA65_min;
            this.max = DFA65_max;
            this.accept = DFA65_accept;
            this.special = DFA65_special;
            this.transition = DFA65_transition;
        }
        public String getDescription() {
            return "396:14: ( simpleStmt ';' )?";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA65_2 = input.LA(1);

                         
                        int index65_2 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred109_Go()) ) {s = 1;}

                        else if ( (true) ) {s = 10;}

                         
                        input.seek(index65_2);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA65_3 = input.LA(1);

                         
                        int index65_3 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred109_Go()) ) {s = 1;}

                        else if ( (true) ) {s = 10;}

                         
                        input.seek(index65_3);
                        if ( s>=0 ) return s;
                        break;
                    case 2 : 
                        int LA65_4 = input.LA(1);

                         
                        int index65_4 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred109_Go()) ) {s = 1;}

                        else if ( (true) ) {s = 10;}

                         
                        input.seek(index65_4);
                        if ( s>=0 ) return s;
                        break;
                    case 3 : 
                        int LA65_5 = input.LA(1);

                         
                        int index65_5 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred109_Go()) ) {s = 1;}

                        else if ( (true) ) {s = 10;}

                         
                        input.seek(index65_5);
                        if ( s>=0 ) return s;
                        break;
                    case 4 : 
                        int LA65_6 = input.LA(1);

                         
                        int index65_6 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred109_Go()) ) {s = 1;}

                        else if ( (true) ) {s = 10;}

                         
                        input.seek(index65_6);
                        if ( s>=0 ) return s;
                        break;
                    case 5 : 
                        int LA65_7 = input.LA(1);

                         
                        int index65_7 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred109_Go()) ) {s = 1;}

                        else if ( (true) ) {s = 10;}

                         
                        input.seek(index65_7);
                        if ( s>=0 ) return s;
                        break;
                    case 6 : 
                        int LA65_8 = input.LA(1);

                         
                        int index65_8 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred109_Go()) ) {s = 1;}

                        else if ( (true) ) {s = 10;}

                         
                        input.seek(index65_8);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 65, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA71_eotS =
        "\15\uffff";
    static final String DFA71_eofS =
        "\15\uffff";
    static final String DFA71_minS =
        "\1\16\10\0\4\uffff";
    static final String DFA71_maxS =
        "\1\67\10\0\4\uffff";
    static final String DFA71_acceptS =
        "\11\uffff\1\2\1\4\1\1\1\3";
    static final String DFA71_specialS =
        "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\4\uffff}>";
    static final String[] DFA71_transitionS = {
            "\1\5\3\uffff\1\1\2\uffff\2\1\2\uffff\1\1\7\uffff\1\1\1\uffff"+
            "\1\10\6\uffff\1\6\1\uffff\1\3\1\uffff\1\2\1\12\1\11\2\uffff"+
            "\1\7\3\uffff\1\4",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA71_eot = DFA.unpackEncodedString(DFA71_eotS);
    static final short[] DFA71_eof = DFA.unpackEncodedString(DFA71_eofS);
    static final char[] DFA71_min = DFA.unpackEncodedStringToUnsignedChars(DFA71_minS);
    static final char[] DFA71_max = DFA.unpackEncodedStringToUnsignedChars(DFA71_maxS);
    static final short[] DFA71_accept = DFA.unpackEncodedString(DFA71_acceptS);
    static final short[] DFA71_special = DFA.unpackEncodedString(DFA71_specialS);
    static final short[][] DFA71_transition;

    static {
        int numStates = DFA71_transitionS.length;
        DFA71_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA71_transition[i] = DFA.unpackEncodedString(DFA71_transitionS[i]);
        }
    }

    class DFA71 extends DFA {

        public DFA71(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 71;
            this.eot = DFA71_eot;
            this.eof = DFA71_eof;
            this.min = DFA71_min;
            this.max = DFA71_max;
            this.accept = DFA71_accept;
            this.special = DFA71_special;
            this.transition = DFA71_transition;
        }
        public String getDescription() {
            return "407:11: ( condition | forClause | rangeClause )?";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA71_1 = input.LA(1);

                         
                        int index71_1 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred115_Go()) ) {s = 11;}

                        else if ( (synpred116_Go()) ) {s = 9;}

                        else if ( (synpred117_Go()) ) {s = 12;}

                         
                        input.seek(index71_1);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA71_2 = input.LA(1);

                         
                        int index71_2 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred115_Go()) ) {s = 11;}

                        else if ( (synpred116_Go()) ) {s = 9;}

                        else if ( (synpred117_Go()) ) {s = 12;}

                         
                        input.seek(index71_2);
                        if ( s>=0 ) return s;
                        break;
                    case 2 : 
                        int LA71_3 = input.LA(1);

                         
                        int index71_3 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred115_Go()) ) {s = 11;}

                        else if ( (synpred116_Go()) ) {s = 9;}

                        else if ( (synpred117_Go()) ) {s = 12;}

                         
                        input.seek(index71_3);
                        if ( s>=0 ) return s;
                        break;
                    case 3 : 
                        int LA71_4 = input.LA(1);

                         
                        int index71_4 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred115_Go()) ) {s = 11;}

                        else if ( (synpred116_Go()) ) {s = 9;}

                        else if ( (synpred117_Go()) ) {s = 12;}

                         
                        input.seek(index71_4);
                        if ( s>=0 ) return s;
                        break;
                    case 4 : 
                        int LA71_5 = input.LA(1);

                         
                        int index71_5 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred115_Go()) ) {s = 11;}

                        else if ( (synpred116_Go()) ) {s = 9;}

                        else if ( (synpred117_Go()) ) {s = 12;}

                         
                        input.seek(index71_5);
                        if ( s>=0 ) return s;
                        break;
                    case 5 : 
                        int LA71_6 = input.LA(1);

                         
                        int index71_6 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred115_Go()) ) {s = 11;}

                        else if ( (synpred116_Go()) ) {s = 9;}

                        else if ( (synpred117_Go()) ) {s = 12;}

                         
                        input.seek(index71_6);
                        if ( s>=0 ) return s;
                        break;
                    case 6 : 
                        int LA71_7 = input.LA(1);

                         
                        int index71_7 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred115_Go()) ) {s = 11;}

                        else if ( (synpred116_Go()) ) {s = 9;}

                        else if ( (synpred117_Go()) ) {s = 12;}

                         
                        input.seek(index71_7);
                        if ( s>=0 ) return s;
                        break;
                    case 7 : 
                        int LA71_8 = input.LA(1);

                         
                        int index71_8 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred115_Go()) ) {s = 11;}

                        else if ( (synpred116_Go()) ) {s = 9;}

                        else if ( (synpred117_Go()) ) {s = 12;}

                         
                        input.seek(index71_8);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 71, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA77_eotS =
        "\13\uffff";
    static final String DFA77_eofS =
        "\13\uffff";
    static final String DFA77_minS =
        "\1\16\10\0\2\uffff";
    static final String DFA77_maxS =
        "\1\67\10\0\2\uffff";
    static final String DFA77_acceptS =
        "\11\uffff\1\2\1\1";
    static final String DFA77_specialS =
        "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\2\uffff}>";
    static final String[] DFA77_transitionS = {
            "\1\5\3\uffff\1\1\2\uffff\2\1\2\uffff\1\1\7\uffff\1\1\1\uffff"+
            "\1\10\1\uffff\1\11\4\uffff\1\6\1\uffff\1\3\1\uffff\1\2\4\uffff"+
            "\1\7\3\uffff\1\4",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "",
            ""
    };

    static final short[] DFA77_eot = DFA.unpackEncodedString(DFA77_eotS);
    static final short[] DFA77_eof = DFA.unpackEncodedString(DFA77_eofS);
    static final char[] DFA77_min = DFA.unpackEncodedStringToUnsignedChars(DFA77_minS);
    static final char[] DFA77_max = DFA.unpackEncodedStringToUnsignedChars(DFA77_maxS);
    static final short[] DFA77_accept = DFA.unpackEncodedString(DFA77_acceptS);
    static final short[] DFA77_special = DFA.unpackEncodedString(DFA77_specialS);
    static final short[][] DFA77_transition;

    static {
        int numStates = DFA77_transitionS.length;
        DFA77_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA77_transition[i] = DFA.unpackEncodedString(DFA77_transitionS[i]);
        }
    }

    class DFA77 extends DFA {

        public DFA77(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 77;
            this.eot = DFA77_eot;
            this.eof = DFA77_eof;
            this.min = DFA77_min;
            this.max = DFA77_max;
            this.accept = DFA77_accept;
            this.special = DFA77_special;
            this.transition = DFA77_transition;
        }
        public String getDescription() {
            return "429:12: ( sendExpr | recvExpr )";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA77_1 = input.LA(1);

                         
                        int index77_1 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred124_Go()) ) {s = 10;}

                        else if ( (true) ) {s = 9;}

                         
                        input.seek(index77_1);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA77_2 = input.LA(1);

                         
                        int index77_2 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred124_Go()) ) {s = 10;}

                        else if ( (true) ) {s = 9;}

                         
                        input.seek(index77_2);
                        if ( s>=0 ) return s;
                        break;
                    case 2 : 
                        int LA77_3 = input.LA(1);

                         
                        int index77_3 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred124_Go()) ) {s = 10;}

                        else if ( (true) ) {s = 9;}

                         
                        input.seek(index77_3);
                        if ( s>=0 ) return s;
                        break;
                    case 3 : 
                        int LA77_4 = input.LA(1);

                         
                        int index77_4 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred124_Go()) ) {s = 10;}

                        else if ( (true) ) {s = 9;}

                         
                        input.seek(index77_4);
                        if ( s>=0 ) return s;
                        break;
                    case 4 : 
                        int LA77_5 = input.LA(1);

                         
                        int index77_5 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred124_Go()) ) {s = 10;}

                        else if ( (true) ) {s = 9;}

                         
                        input.seek(index77_5);
                        if ( s>=0 ) return s;
                        break;
                    case 5 : 
                        int LA77_6 = input.LA(1);

                         
                        int index77_6 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred124_Go()) ) {s = 10;}

                        else if ( (true) ) {s = 9;}

                         
                        input.seek(index77_6);
                        if ( s>=0 ) return s;
                        break;
                    case 6 : 
                        int LA77_7 = input.LA(1);

                         
                        int index77_7 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred124_Go()) ) {s = 10;}

                        else if ( (true) ) {s = 9;}

                         
                        input.seek(index77_7);
                        if ( s>=0 ) return s;
                        break;
                    case 7 : 
                        int LA77_8 = input.LA(1);

                         
                        int index77_8 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred124_Go()) ) {s = 10;}

                        else if ( (true) ) {s = 9;}

                         
                        input.seek(index77_8);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 77, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA85_eotS =
        "\15\uffff";
    static final String DFA85_eofS =
        "\15\uffff";
    static final String DFA85_minS =
        "\1\16\3\0\1\uffff\1\0\1\uffff\1\0\2\uffff\1\0\2\uffff";
    static final String DFA85_maxS =
        "\1\70\3\0\1\uffff\1\0\1\uffff\1\0\2\uffff\1\0\2\uffff";
    static final String DFA85_acceptS =
        "\4\uffff\1\1\6\uffff\1\2\1\uffff";
    static final String DFA85_specialS =
        "\1\uffff\1\0\1\1\1\2\1\uffff\1\3\1\uffff\1\4\2\uffff\1\5\2\uffff}>";
    static final String[] DFA85_transitionS = {
            "\1\1\3\uffff\1\13\2\uffff\2\13\2\uffff\1\13\7\uffff\1\13\1\uffff"+
            "\1\13\1\uffff\1\4\4\uffff\1\12\1\uffff\1\2\1\uffff\1\3\3\uffff"+
            "\1\4\1\5\2\uffff\1\4\1\7\1\4",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "",
            "\1\uffff",
            "",
            "\1\uffff",
            "",
            "",
            "\1\uffff",
            "",
            ""
    };

    static final short[] DFA85_eot = DFA.unpackEncodedString(DFA85_eotS);
    static final short[] DFA85_eof = DFA.unpackEncodedString(DFA85_eofS);
    static final char[] DFA85_min = DFA.unpackEncodedStringToUnsignedChars(DFA85_minS);
    static final char[] DFA85_max = DFA.unpackEncodedStringToUnsignedChars(DFA85_maxS);
    static final short[] DFA85_accept = DFA.unpackEncodedString(DFA85_acceptS);
    static final short[] DFA85_special = DFA.unpackEncodedString(DFA85_specialS);
    static final short[][] DFA85_transition;

    static {
        int numStates = DFA85_transitionS.length;
        DFA85_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA85_transition[i] = DFA.unpackEncodedString(DFA85_transitionS[i]);
        }
    }

    class DFA85 extends DFA {

        public DFA85(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 85;
            this.eot = DFA85_eot;
            this.eof = DFA85_eof;
            this.min = DFA85_min;
            this.max = DFA85_max;
            this.accept = DFA85_accept;
            this.special = DFA85_special;
            this.transition = DFA85_transition;
        }
        public String getDescription() {
            return "456:1: builtinArgs : ( type ( ',' expressionList )? | expressionList );";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA85_1 = input.LA(1);

                         
                        int index85_1 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred133_Go()) ) {s = 4;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index85_1);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA85_2 = input.LA(1);

                         
                        int index85_2 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred133_Go()) ) {s = 4;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index85_2);
                        if ( s>=0 ) return s;
                        break;
                    case 2 : 
                        int LA85_3 = input.LA(1);

                         
                        int index85_3 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred133_Go()) ) {s = 4;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index85_3);
                        if ( s>=0 ) return s;
                        break;
                    case 3 : 
                        int LA85_5 = input.LA(1);

                         
                        int index85_5 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred133_Go()) ) {s = 4;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index85_5);
                        if ( s>=0 ) return s;
                        break;
                    case 4 : 
                        int LA85_7 = input.LA(1);

                         
                        int index85_7 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred133_Go()) ) {s = 4;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index85_7);
                        if ( s>=0 ) return s;
                        break;
                    case 5 : 
                        int LA85_10 = input.LA(1);

                         
                        int index85_10 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred133_Go()) ) {s = 4;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index85_10);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 85, _s, input);
            error(nvae);
            throw nvae;
        }
    }
 

    public static final BitSet FOLLOW_typeName_in_type1259 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_typeLit_in_type1263 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_42_in_type1267 = new BitSet(new long[]{0x01CC542000004000L});
    public static final BitSet FOLLOW_type_in_type1269 = new BitSet(new long[]{0x0000080000000000L});
    public static final BitSet FOLLOW_43_in_type1271 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_qualifiedIdent_in_typeName1283 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_arrayType_in_typeLit1295 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_structType_in_typeLit1299 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_pointerType_in_typeLit1303 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_functionType_in_typeLit1307 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_interfaceType_in_typeLit1311 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_sliceType_in_typeLit1320 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_mapType_in_typeLit1324 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_channelType_in_typeLit1328 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_44_in_arrayType1342 = new BitSet(new long[]{0x0088540A02644000L});
    public static final BitSet FOLLOW_arrayLength_in_arrayType1344 = new BitSet(new long[]{0x0000200000000000L});
    public static final BitSet FOLLOW_45_in_arrayType1346 = new BitSet(new long[]{0x01CC542000004000L});
    public static final BitSet FOLLOW_elementType_in_arrayType1348 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expression_in_arrayLength1359 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_type_in_elementType1370 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_44_in_sliceType1382 = new BitSet(new long[]{0x0000200000000000L});
    public static final BitSet FOLLOW_45_in_sliceType1384 = new BitSet(new long[]{0x01CC542000004000L});
    public static final BitSet FOLLOW_elementType_in_sliceType1386 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_46_in_structType1402 = new BitSet(new long[]{0x0000800000000000L});
    public static final BitSet FOLLOW_47_in_structType1404 = new BitSet(new long[]{0x0006000000004000L});
    public static final BitSet FOLLOW_fieldDecl_in_structType1408 = new BitSet(new long[]{0x0001000000000000L});
    public static final BitSet FOLLOW_48_in_structType1410 = new BitSet(new long[]{0x0006000000004000L});
    public static final BitSet FOLLOW_49_in_structType1415 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_identifierList_in_fieldDecl1432 = new BitSet(new long[]{0x01CC542000004000L});
    public static final BitSet FOLLOW_type_in_fieldDecl1434 = new BitSet(new long[]{0x0000000200000002L});
    public static final BitSet FOLLOW_anonymousField_in_fieldDecl1438 = new BitSet(new long[]{0x0000000200000002L});
    public static final BitSet FOLLOW_tag_in_fieldDecl1442 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_50_in_anonymousField1456 = new BitSet(new long[]{0x0000000000004000L});
    public static final BitSet FOLLOW_typeName_in_anonymousField1460 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_String_lit_in_tag1482 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_50_in_pointerType1494 = new BitSet(new long[]{0x01CC542000004000L});
    public static final BitSet FOLLOW_baseType_in_pointerType1496 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_type_in_baseType1507 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_51_in_functionType1521 = new BitSet(new long[]{0x0000040000000000L});
    public static final BitSet FOLLOW_signature_in_functionType1523 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_parameters_in_signature1539 = new BitSet(new long[]{0x01CC542000004002L});
    public static final BitSet FOLLOW_result_in_signature1543 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_parameters_in_result1565 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_type_in_result1569 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_42_in_parameters1584 = new BitSet(new long[]{0x01EC5C2000004000L});
    public static final BitSet FOLLOW_parameterList_in_parameters1588 = new BitSet(new long[]{0x0010080000000000L});
    public static final BitSet FOLLOW_52_in_parameters1592 = new BitSet(new long[]{0x0000080000000000L});
    public static final BitSet FOLLOW_43_in_parameters1600 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_parameterDecl_in_parameterList1612 = new BitSet(new long[]{0x0010000000000002L});
    public static final BitSet FOLLOW_52_in_parameterList1616 = new BitSet(new long[]{0x01EC542000004000L});
    public static final BitSet FOLLOW_parameterDecl_in_parameterList1618 = new BitSet(new long[]{0x0010000000000002L});
    public static final BitSet FOLLOW_identifierList_in_parameterDecl1635 = new BitSet(new long[]{0x01EC542000004000L});
    public static final BitSet FOLLOW_type_in_parameterDecl1642 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_53_in_parameterDecl1646 = new BitSet(new long[]{0x01CC542000004002L});
    public static final BitSet FOLLOW_type_in_parameterDecl1650 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_54_in_interfaceType1672 = new BitSet(new long[]{0x0000800000000000L});
    public static final BitSet FOLLOW_47_in_interfaceType1674 = new BitSet(new long[]{0x0002000000004000L});
    public static final BitSet FOLLOW_methodSpec_in_interfaceType1678 = new BitSet(new long[]{0x0001000000000000L});
    public static final BitSet FOLLOW_48_in_interfaceType1680 = new BitSet(new long[]{0x0002000000004000L});
    public static final BitSet FOLLOW_49_in_interfaceType1685 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_methodName_in_methodSpec1704 = new BitSet(new long[]{0x0000040000000000L});
    public static final BitSet FOLLOW_signature_in_methodSpec1706 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_interfaceTypeName_in_methodSpec1710 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Identifier_in_methodName1729 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_typeName_in_interfaceTypeName1741 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_55_in_mapType1757 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_44_in_mapType1759 = new BitSet(new long[]{0x01CC542000004000L});
    public static final BitSet FOLLOW_keyType_in_mapType1761 = new BitSet(new long[]{0x0000200000000000L});
    public static final BitSet FOLLOW_45_in_mapType1763 = new BitSet(new long[]{0x01CC542000004000L});
    public static final BitSet FOLLOW_elementType_in_mapType1765 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_type_in_keyType1780 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_channel_in_channelType1794 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_sendChannel_in_channelType1798 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_recvChannel_in_channelType1802 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_56_in_channel1819 = new BitSet(new long[]{0x01CC542000004000L});
    public static final BitSet FOLLOW_elementType_in_channel1821 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_56_in_sendChannel1834 = new BitSet(new long[]{0x0000002000000000L});
    public static final BitSet FOLLOW_Com_op_in_sendChannel1836 = new BitSet(new long[]{0x01CC542000004000L});
    public static final BitSet FOLLOW_elementType_in_sendChannel1838 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Com_op_in_recvChannel1851 = new BitSet(new long[]{0x0100000000000000L});
    public static final BitSet FOLLOW_56_in_recvChannel1853 = new BitSet(new long[]{0x01CC542000004000L});
    public static final BitSet FOLLOW_elementType_in_recvChannel1855 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_47_in_block1866 = new BitSet(new long[]{0x1A8AD40A02644000L,0x000000000001FE94L});
    public static final BitSet FOLLOW_statement_in_block1870 = new BitSet(new long[]{0x0001000000000000L});
    public static final BitSet FOLLOW_48_in_block1872 = new BitSet(new long[]{0x1A8AD40A02644000L,0x000000000001FE94L});
    public static final BitSet FOLLOW_49_in_block1877 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_constDecl_in_declaration1891 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_typeDecl_in_declaration1895 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_varDecl_in_declaration1899 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_declaration_in_topLevelDecl1911 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_functionDecl_in_topLevelDecl1915 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_methodDecl_in_topLevelDecl1919 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_57_in_constDecl1936 = new BitSet(new long[]{0x0000040000004000L});
    public static final BitSet FOLLOW_constSpec_in_constDecl1940 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_42_in_constDecl1944 = new BitSet(new long[]{0x0000080000004000L});
    public static final BitSet FOLLOW_constSpec_in_constDecl1948 = new BitSet(new long[]{0x0001000000000000L});
    public static final BitSet FOLLOW_48_in_constDecl1950 = new BitSet(new long[]{0x0000080000004000L});
    public static final BitSet FOLLOW_43_in_constDecl1955 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_identifierList_in_constSpec1973 = new BitSet(new long[]{0x05CC542000004002L});
    public static final BitSet FOLLOW_type_in_constSpec1979 = new BitSet(new long[]{0x0400000000000000L});
    public static final BitSet FOLLOW_58_in_constSpec1984 = new BitSet(new long[]{0x0088540A02644000L});
    public static final BitSet FOLLOW_expressionList_in_constSpec1986 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Identifier_in_identifierList2002 = new BitSet(new long[]{0x0010000000000002L});
    public static final BitSet FOLLOW_52_in_identifierList2006 = new BitSet(new long[]{0x0000000000004000L});
    public static final BitSet FOLLOW_Identifier_in_identifierList2008 = new BitSet(new long[]{0x0010000000000002L});
    public static final BitSet FOLLOW_expression_in_expressionList2022 = new BitSet(new long[]{0x0010000000000002L});
    public static final BitSet FOLLOW_52_in_expressionList2026 = new BitSet(new long[]{0x0088540A02644000L});
    public static final BitSet FOLLOW_expression_in_expressionList2028 = new BitSet(new long[]{0x0010000000000002L});
    public static final BitSet FOLLOW_59_in_typeDecl2047 = new BitSet(new long[]{0x0000040000004000L});
    public static final BitSet FOLLOW_typeSpec_in_typeDecl2051 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_42_in_typeDecl2055 = new BitSet(new long[]{0x0000080000004000L});
    public static final BitSet FOLLOW_typeSpec_in_typeDecl2059 = new BitSet(new long[]{0x0001000000000000L});
    public static final BitSet FOLLOW_48_in_typeDecl2061 = new BitSet(new long[]{0x0000080000004000L});
    public static final BitSet FOLLOW_43_in_typeDecl2066 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Identifier_in_typeSpec2083 = new BitSet(new long[]{0x01CC542000004000L});
    public static final BitSet FOLLOW_type_in_typeSpec2085 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_60_in_varDecl2101 = new BitSet(new long[]{0x0000040000004000L});
    public static final BitSet FOLLOW_varSpec_in_varDecl2105 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_42_in_varDecl2109 = new BitSet(new long[]{0x0000080000004000L});
    public static final BitSet FOLLOW_varSpec_in_varDecl2113 = new BitSet(new long[]{0x0001000000000000L});
    public static final BitSet FOLLOW_48_in_varDecl2115 = new BitSet(new long[]{0x0000080000004000L});
    public static final BitSet FOLLOW_43_in_varDecl2120 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_identifierList_in_varSpec2137 = new BitSet(new long[]{0x05CC542000004000L});
    public static final BitSet FOLLOW_type_in_varSpec2141 = new BitSet(new long[]{0x0400000000000002L});
    public static final BitSet FOLLOW_58_in_varSpec2145 = new BitSet(new long[]{0x0088540A02644000L});
    public static final BitSet FOLLOW_expressionList_in_varSpec2147 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_58_in_varSpec2154 = new BitSet(new long[]{0x0088540A02644000L});
    public static final BitSet FOLLOW_expressionList_in_varSpec2156 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_identifierList_in_shortVarDecl2170 = new BitSet(new long[]{0x2000000000000000L});
    public static final BitSet FOLLOW_61_in_shortVarDecl2172 = new BitSet(new long[]{0x0088540A02644000L});
    public static final BitSet FOLLOW_expressionList_in_shortVarDecl2174 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_51_in_functionDecl2186 = new BitSet(new long[]{0x0000000000004000L});
    public static final BitSet FOLLOW_Identifier_in_functionDecl2188 = new BitSet(new long[]{0x0000040000000000L});
    public static final BitSet FOLLOW_signature_in_functionDecl2190 = new BitSet(new long[]{0x0000800000000002L});
    public static final BitSet FOLLOW_body_in_functionDecl2194 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_block_in_body2216 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_51_in_methodDecl2229 = new BitSet(new long[]{0x0000040000000000L});
    public static final BitSet FOLLOW_receiver_in_methodDecl2231 = new BitSet(new long[]{0x0000000000004000L});
    public static final BitSet FOLLOW_methodName_in_methodDecl2233 = new BitSet(new long[]{0x0000040000000000L});
    public static final BitSet FOLLOW_signature_in_methodDecl2235 = new BitSet(new long[]{0x0000800000000002L});
    public static final BitSet FOLLOW_body_in_methodDecl2239 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_42_in_receiver2257 = new BitSet(new long[]{0x0004000000004000L});
    public static final BitSet FOLLOW_Identifier_in_receiver2261 = new BitSet(new long[]{0x0004000000004000L});
    public static final BitSet FOLLOW_50_in_receiver2268 = new BitSet(new long[]{0x0004000000004000L});
    public static final BitSet FOLLOW_baseTypeName_in_receiver2273 = new BitSet(new long[]{0x0000080000000000L});
    public static final BitSet FOLLOW_43_in_receiver2275 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Identifier_in_baseTypeName2286 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_literal_in_operand2300 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_qualifiedIdent_in_operand2304 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_methodExpr_in_operand2308 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_42_in_operand2312 = new BitSet(new long[]{0x0088540A02644000L});
    public static final BitSet FOLLOW_expression_in_operand2314 = new BitSet(new long[]{0x0000080000000000L});
    public static final BitSet FOLLOW_43_in_operand2316 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_basicLit_in_literal2330 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_compositeLit_in_literal2334 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_functionLit_in_literal2338 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_basicLit0 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_packageName_in_qualifiedIdent2381 = new BitSet(new long[]{0x4000000000000000L});
    public static final BitSet FOLLOW_62_in_qualifiedIdent2383 = new BitSet(new long[]{0x0000000000004000L});
    public static final BitSet FOLLOW_Identifier_in_qualifiedIdent2388 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_literalType_in_compositeLit2401 = new BitSet(new long[]{0x0000800000000000L});
    public static final BitSet FOLLOW_47_in_compositeLit2403 = new BitSet(new long[]{0x008A540A02644000L});
    public static final BitSet FOLLOW_elementList_in_compositeLit2407 = new BitSet(new long[]{0x0012000000000000L});
    public static final BitSet FOLLOW_52_in_compositeLit2411 = new BitSet(new long[]{0x0002000000000000L});
    public static final BitSet FOLLOW_49_in_compositeLit2419 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_structType_in_literalType2432 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_arrayType_in_literalType2436 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_44_in_literalType2440 = new BitSet(new long[]{0x0020000000000000L});
    public static final BitSet FOLLOW_53_in_literalType2442 = new BitSet(new long[]{0x0000200000000000L});
    public static final BitSet FOLLOW_45_in_literalType2444 = new BitSet(new long[]{0x01CC542000004000L});
    public static final BitSet FOLLOW_elementType_in_literalType2446 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_sliceType_in_literalType2466 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_mapType_in_literalType2470 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_typeName_in_literalType2474 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_42_in_literalType2478 = new BitSet(new long[]{0x0080540000004000L});
    public static final BitSet FOLLOW_literalType_in_literalType2480 = new BitSet(new long[]{0x0000080000000000L});
    public static final BitSet FOLLOW_43_in_literalType2482 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_element_in_elementList2495 = new BitSet(new long[]{0x0010000000000002L});
    public static final BitSet FOLLOW_52_in_elementList2499 = new BitSet(new long[]{0x0088540A02644000L});
    public static final BitSet FOLLOW_element_in_elementList2501 = new BitSet(new long[]{0x0010000000000002L});
    public static final BitSet FOLLOW_key_in_element2523 = new BitSet(new long[]{0x8000000000000000L});
    public static final BitSet FOLLOW_63_in_element2525 = new BitSet(new long[]{0x0088540A02644000L});
    public static final BitSet FOLLOW_value_in_element2530 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_fieldName_in_key2551 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_elementIndex_in_key2555 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Identifier_in_fieldName2570 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expression_in_elementIndex2582 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expression_in_value2601 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_functionType_in_functionLit2613 = new BitSet(new long[]{0x0000800000000000L});
    public static final BitSet FOLLOW_body_in_functionLit2615 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_operand_in_primaryExpr2630 = new BitSet(new long[]{0x4000140000000002L});
    public static final BitSet FOLLOW_conversion_in_primaryExpr2634 = new BitSet(new long[]{0x4000140000000002L});
    public static final BitSet FOLLOW_builtinCall_in_primaryExpr2638 = new BitSet(new long[]{0x4000140000000002L});
    public static final BitSet FOLLOW_selector_in_primaryExpr2642 = new BitSet(new long[]{0x4000140000000002L});
    public static final BitSet FOLLOW_index_in_primaryExpr2646 = new BitSet(new long[]{0x4000140000000002L});
    public static final BitSet FOLLOW_slice_in_primaryExpr2650 = new BitSet(new long[]{0x4000140000000002L});
    public static final BitSet FOLLOW_typeAssertion_in_primaryExpr2654 = new BitSet(new long[]{0x4000140000000002L});
    public static final BitSet FOLLOW_call_in_primaryExpr2658 = new BitSet(new long[]{0x4000140000000002L});
    public static final BitSet FOLLOW_62_in_selector2678 = new BitSet(new long[]{0x0000000000004000L});
    public static final BitSet FOLLOW_Identifier_in_selector2680 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_44_in_index2700 = new BitSet(new long[]{0x0088540A02644000L});
    public static final BitSet FOLLOW_expression_in_index2702 = new BitSet(new long[]{0x0000200000000000L});
    public static final BitSet FOLLOW_45_in_index2704 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_44_in_slice2724 = new BitSet(new long[]{0x0088540A02644000L});
    public static final BitSet FOLLOW_expression_in_slice2726 = new BitSet(new long[]{0x8000000000000000L});
    public static final BitSet FOLLOW_63_in_slice2728 = new BitSet(new long[]{0x0088740A02644000L});
    public static final BitSet FOLLOW_expression_in_slice2732 = new BitSet(new long[]{0x0000200000000000L});
    public static final BitSet FOLLOW_45_in_slice2737 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_62_in_typeAssertion2749 = new BitSet(new long[]{0x0000040000000000L});
    public static final BitSet FOLLOW_42_in_typeAssertion2751 = new BitSet(new long[]{0x01CC542000004000L});
    public static final BitSet FOLLOW_type_in_typeAssertion2753 = new BitSet(new long[]{0x0000080000000000L});
    public static final BitSet FOLLOW_43_in_typeAssertion2755 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_42_in_call2776 = new BitSet(new long[]{0x00885C0A02644000L});
    public static final BitSet FOLLOW_expressionList_in_call2780 = new BitSet(new long[]{0x0010080000000000L});
    public static final BitSet FOLLOW_52_in_call2784 = new BitSet(new long[]{0x0000080000000000L});
    public static final BitSet FOLLOW_43_in_call2792 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_unaryExpr_in_expression2806 = new BitSet(new long[]{0x0000000400000002L});
    public static final BitSet FOLLOW_Binary_op_in_expression2810 = new BitSet(new long[]{0x0088540A02644000L});
    public static final BitSet FOLLOW_unaryExpr_in_expression2812 = new BitSet(new long[]{0x0000000400000002L});
    public static final BitSet FOLLOW_primaryExpr_in_unaryExpr2826 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Unary_op_in_unaryExpr2830 = new BitSet(new long[]{0x0088540A02644000L});
    public static final BitSet FOLLOW_unaryExpr_in_unaryExpr2832 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_receiverType_in_methodExpr3061 = new BitSet(new long[]{0x4000000000000000L});
    public static final BitSet FOLLOW_62_in_methodExpr3063 = new BitSet(new long[]{0x0000000000004000L});
    public static final BitSet FOLLOW_methodName_in_methodExpr3065 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_typeName_in_receiverType3077 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_42_in_receiverType3081 = new BitSet(new long[]{0x0004000000000000L});
    public static final BitSet FOLLOW_50_in_receiverType3083 = new BitSet(new long[]{0x0000000000004000L});
    public static final BitSet FOLLOW_typeName_in_receiverType3085 = new BitSet(new long[]{0x0000080000000000L});
    public static final BitSet FOLLOW_43_in_receiverType3087 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_literalType_in_conversion3099 = new BitSet(new long[]{0x0000040000000000L});
    public static final BitSet FOLLOW_42_in_conversion3101 = new BitSet(new long[]{0x0088540A02644000L});
    public static final BitSet FOLLOW_expression_in_conversion3103 = new BitSet(new long[]{0x0000080000000000L});
    public static final BitSet FOLLOW_43_in_conversion3105 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_declaration_in_statement3118 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_labeledStmt_in_statement3122 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_simpleStmt_in_statement3126 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_goStmt_in_statement3131 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_returnStmt_in_statement3135 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_breakStmt_in_statement3139 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_continueStmt_in_statement3143 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_gotoStmt_in_statement3147 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_fallthroughStmt_in_statement3152 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_block_in_statement3156 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ifStmt_in_statement3160 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_switchStmt_in_statement3164 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_selectStmt_in_statement3168 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_forStmt_in_statement3172 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_deferStmt_in_statement3177 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_emptyStmt_in_simpleStmt3189 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expressionStmt_in_simpleStmt3193 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_incDecStmt_in_simpleStmt3197 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_assignment_in_simpleStmt3201 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_shortVarDecl_in_simpleStmt3205 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_label_in_labeledStmt3228 = new BitSet(new long[]{0x8000000000000000L});
    public static final BitSet FOLLOW_63_in_labeledStmt3230 = new BitSet(new long[]{0x1A88D40A02644000L,0x000000000001FE94L});
    public static final BitSet FOLLOW_statement_in_labeledStmt3232 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Identifier_in_label3249 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expression_in_expressionStmt3261 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expression_in_incDecStmt3273 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000003L});
    public static final BitSet FOLLOW_set_in_incDecStmt3275 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expressionList_in_assignment3295 = new BitSet(new long[]{0x0000020000000000L});
    public static final BitSet FOLLOW_Assign_op_in_assignment3297 = new BitSet(new long[]{0x0088540A02644000L});
    public static final BitSet FOLLOW_expressionList_in_assignment3299 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_66_in_ifStmt3337 = new BitSet(new long[]{0x0088D40A02644000L});
    public static final BitSet FOLLOW_simpleStmt_in_ifStmt3341 = new BitSet(new long[]{0x0001000000000000L});
    public static final BitSet FOLLOW_48_in_ifStmt3343 = new BitSet(new long[]{0x0088D40A02644000L});
    public static final BitSet FOLLOW_expression_in_ifStmt3350 = new BitSet(new long[]{0x0000800000000000L});
    public static final BitSet FOLLOW_block_in_ifStmt3355 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000008L});
    public static final BitSet FOLLOW_67_in_ifStmt3359 = new BitSet(new long[]{0x1A88D40A02644000L,0x000000000001FE94L});
    public static final BitSet FOLLOW_statement_in_ifStmt3361 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_exprSwitchStmt_in_switchStmt3376 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_typeSwitchStmt_in_switchStmt3380 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_68_in_exprSwitchStmt3392 = new BitSet(new long[]{0x0088D40A02644000L});
    public static final BitSet FOLLOW_simpleStmt_in_exprSwitchStmt3396 = new BitSet(new long[]{0x0001000000000000L});
    public static final BitSet FOLLOW_48_in_exprSwitchStmt3398 = new BitSet(new long[]{0x0088D40A02644000L});
    public static final BitSet FOLLOW_expression_in_exprSwitchStmt3405 = new BitSet(new long[]{0x0000800000000000L});
    public static final BitSet FOLLOW_47_in_exprSwitchStmt3410 = new BitSet(new long[]{0x0002000000000000L,0x0000000000000060L});
    public static final BitSet FOLLOW_exprCaseClause_in_exprSwitchStmt3414 = new BitSet(new long[]{0x0002000000000000L,0x0000000000000060L});
    public static final BitSet FOLLOW_49_in_exprSwitchStmt3419 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_exprSwitchCase_in_exprCaseClause3430 = new BitSet(new long[]{0x8000000000000000L});
    public static final BitSet FOLLOW_63_in_exprCaseClause3432 = new BitSet(new long[]{0x1A88D40A02644002L,0x000000000001FE94L});
    public static final BitSet FOLLOW_statement_in_exprCaseClause3436 = new BitSet(new long[]{0x0001000000000000L});
    public static final BitSet FOLLOW_48_in_exprCaseClause3438 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_69_in_exprSwitchCase3452 = new BitSet(new long[]{0x0088540A02644000L});
    public static final BitSet FOLLOW_expressionList_in_exprSwitchCase3454 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_70_in_exprSwitchCase3458 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_68_in_typeSwitchStmt3471 = new BitSet(new long[]{0x0088540A02644000L});
    public static final BitSet FOLLOW_simpleStmt_in_typeSwitchStmt3475 = new BitSet(new long[]{0x0001000000000000L});
    public static final BitSet FOLLOW_48_in_typeSwitchStmt3477 = new BitSet(new long[]{0x0088540A02644000L});
    public static final BitSet FOLLOW_typeSwitchGuard_in_typeSwitchStmt3482 = new BitSet(new long[]{0x0000800000000000L});
    public static final BitSet FOLLOW_47_in_typeSwitchStmt3484 = new BitSet(new long[]{0x0002000000000000L,0x0000000000000060L});
    public static final BitSet FOLLOW_typeCaseClause_in_typeSwitchStmt3488 = new BitSet(new long[]{0x0002000000000000L,0x0000000000000060L});
    public static final BitSet FOLLOW_49_in_typeSwitchStmt3493 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Identifier_in_typeSwitchGuard3505 = new BitSet(new long[]{0x2000000000000000L});
    public static final BitSet FOLLOW_61_in_typeSwitchGuard3507 = new BitSet(new long[]{0x0088540202644000L});
    public static final BitSet FOLLOW_primaryExpr_in_typeSwitchGuard3512 = new BitSet(new long[]{0x4000000000000000L});
    public static final BitSet FOLLOW_62_in_typeSwitchGuard3514 = new BitSet(new long[]{0x0000040000000000L});
    public static final BitSet FOLLOW_42_in_typeSwitchGuard3516 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_59_in_typeSwitchGuard3518 = new BitSet(new long[]{0x0000080000000000L});
    public static final BitSet FOLLOW_43_in_typeSwitchGuard3520 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_typeSwitchCase_in_typeCaseClause3531 = new BitSet(new long[]{0x8000000000000000L});
    public static final BitSet FOLLOW_63_in_typeCaseClause3533 = new BitSet(new long[]{0x1A88D40A02644002L,0x000000000001FE94L});
    public static final BitSet FOLLOW_statement_in_typeCaseClause3537 = new BitSet(new long[]{0x0001000000000000L});
    public static final BitSet FOLLOW_48_in_typeCaseClause3539 = new BitSet(new long[]{0x1A88D40A02644002L,0x000000000001FE94L});
    public static final BitSet FOLLOW_69_in_typeSwitchCase3553 = new BitSet(new long[]{0x01CC542000004000L});
    public static final BitSet FOLLOW_typeList_in_typeSwitchCase3555 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_70_in_typeSwitchCase3559 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_type_in_typeList3576 = new BitSet(new long[]{0x0010000000000002L});
    public static final BitSet FOLLOW_52_in_typeList3580 = new BitSet(new long[]{0x01CC542000004000L});
    public static final BitSet FOLLOW_type_in_typeList3582 = new BitSet(new long[]{0x0010000000000002L});
    public static final BitSet FOLLOW_71_in_forStmt3597 = new BitSet(new long[]{0x0089D40A02644000L});
    public static final BitSet FOLLOW_condition_in_forStmt3601 = new BitSet(new long[]{0x0000800000000000L});
    public static final BitSet FOLLOW_forClause_in_forStmt3605 = new BitSet(new long[]{0x0000800000000000L});
    public static final BitSet FOLLOW_rangeClause_in_forStmt3609 = new BitSet(new long[]{0x0000800000000000L});
    public static final BitSet FOLLOW_block_in_forStmt3614 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expression_in_condition3625 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_initStmt_in_forClause3639 = new BitSet(new long[]{0x0001000000000000L});
    public static final BitSet FOLLOW_48_in_forClause3644 = new BitSet(new long[]{0x0089540A02644000L});
    public static final BitSet FOLLOW_condition_in_forClause3648 = new BitSet(new long[]{0x0001000000000000L});
    public static final BitSet FOLLOW_48_in_forClause3653 = new BitSet(new long[]{0x0088540A02644002L});
    public static final BitSet FOLLOW_postStmt_in_forClause3657 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_simpleStmt_in_initStmt3671 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_simpleStmt_in_postStmt3682 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expressionList_in_rangeClause3694 = new BitSet(new long[]{0x2400000000000000L});
    public static final BitSet FOLLOW_set_in_rangeClause3696 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L});
    public static final BitSet FOLLOW_72_in_rangeClause3706 = new BitSet(new long[]{0x0088540A02644000L});
    public static final BitSet FOLLOW_expression_in_rangeClause3708 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_73_in_goStmt3721 = new BitSet(new long[]{0x0088540A02644000L});
    public static final BitSet FOLLOW_expression_in_goStmt3723 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_74_in_selectStmt3735 = new BitSet(new long[]{0x0000800000000000L});
    public static final BitSet FOLLOW_47_in_selectStmt3737 = new BitSet(new long[]{0x0002000000000000L,0x0000000000000060L});
    public static final BitSet FOLLOW_commClause_in_selectStmt3741 = new BitSet(new long[]{0x0002000000000000L,0x0000000000000060L});
    public static final BitSet FOLLOW_49_in_selectStmt3746 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_commCase_in_commClause3757 = new BitSet(new long[]{0x8000000000000000L});
    public static final BitSet FOLLOW_63_in_commClause3759 = new BitSet(new long[]{0x1A88D40A02644002L,0x000000000001FE94L});
    public static final BitSet FOLLOW_statement_in_commClause3763 = new BitSet(new long[]{0x0001000000000000L});
    public static final BitSet FOLLOW_48_in_commClause3765 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_69_in_commCase3779 = new BitSet(new long[]{0x0088542A02644000L});
    public static final BitSet FOLLOW_sendExpr_in_commCase3783 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_recvExpr_in_commCase3787 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_70_in_commCase3792 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expression_in_sendExpr3803 = new BitSet(new long[]{0x0000002000000000L});
    public static final BitSet FOLLOW_Com_op_in_sendExpr3805 = new BitSet(new long[]{0x0088540A02644000L});
    public static final BitSet FOLLOW_expression_in_sendExpr3807 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expression_in_recvExpr3820 = new BitSet(new long[]{0x2400000000000000L});
    public static final BitSet FOLLOW_set_in_recvExpr3822 = new BitSet(new long[]{0x0000002000000000L});
    public static final BitSet FOLLOW_Com_op_in_recvExpr3835 = new BitSet(new long[]{0x0088540A02644000L});
    public static final BitSet FOLLOW_expression_in_recvExpr3837 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_75_in_returnStmt3848 = new BitSet(new long[]{0x0088540A02644002L});
    public static final BitSet FOLLOW_expressionList_in_returnStmt3852 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_76_in_breakStmt3867 = new BitSet(new long[]{0x0000000000004002L});
    public static final BitSet FOLLOW_label_in_breakStmt3871 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_77_in_continueStmt3886 = new BitSet(new long[]{0x0000000000004002L});
    public static final BitSet FOLLOW_label_in_continueStmt3890 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_78_in_gotoStmt3905 = new BitSet(new long[]{0x0000000000004000L});
    public static final BitSet FOLLOW_label_in_gotoStmt3907 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_79_in_fallthroughStmt3919 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_80_in_deferStmt3931 = new BitSet(new long[]{0x0088540A02644000L});
    public static final BitSet FOLLOW_expression_in_deferStmt3933 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Identifier_in_builtinCall3944 = new BitSet(new long[]{0x0000040000000000L});
    public static final BitSet FOLLOW_42_in_builtinCall3946 = new BitSet(new long[]{0x01CC5C2A02644000L});
    public static final BitSet FOLLOW_builtinArgs_in_builtinCall3950 = new BitSet(new long[]{0x0000080000000000L});
    public static final BitSet FOLLOW_43_in_builtinCall3955 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_type_in_builtinArgs3966 = new BitSet(new long[]{0x0010000000000002L});
    public static final BitSet FOLLOW_52_in_builtinArgs3970 = new BitSet(new long[]{0x0088540A02644000L});
    public static final BitSet FOLLOW_expressionList_in_builtinArgs3972 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expressionList_in_builtinArgs3979 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_packageClause_in_sourceFile3997 = new BitSet(new long[]{0x0001000000000000L});
    public static final BitSet FOLLOW_48_in_sourceFile3999 = new BitSet(new long[]{0x1A08000000000002L,0x0000000000040000L});
    public static final BitSet FOLLOW_importDecl_in_sourceFile4003 = new BitSet(new long[]{0x0001000000000000L});
    public static final BitSet FOLLOW_48_in_sourceFile4005 = new BitSet(new long[]{0x1A08000000000002L,0x0000000000040000L});
    public static final BitSet FOLLOW_topLevelDecl_in_sourceFile4012 = new BitSet(new long[]{0x0001000000000000L});
    public static final BitSet FOLLOW_48_in_sourceFile4014 = new BitSet(new long[]{0x1A08000000000002L});
    public static final BitSet FOLLOW_81_in_packageClause4030 = new BitSet(new long[]{0x0000000000004000L});
    public static final BitSet FOLLOW_packageName_in_packageClause4032 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Identifier_in_packageName4046 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_82_in_importDecl4064 = new BitSet(new long[]{0x4000040200004000L});
    public static final BitSet FOLLOW_importSpec_in_importDecl4068 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_42_in_importDecl4072 = new BitSet(new long[]{0x4000080200004000L});
    public static final BitSet FOLLOW_importSpec_in_importDecl4076 = new BitSet(new long[]{0x0001000000000000L});
    public static final BitSet FOLLOW_48_in_importDecl4078 = new BitSet(new long[]{0x4000080200004000L});
    public static final BitSet FOLLOW_43_in_importDecl4083 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_62_in_importSpec4104 = new BitSet(new long[]{0x4000000200004000L});
    public static final BitSet FOLLOW_packageName_in_importSpec4108 = new BitSet(new long[]{0x4000000200004000L});
    public static final BitSet FOLLOW_importPath_in_importSpec4113 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_String_lit_in_importPath4130 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_result_in_synpred14_Go1543 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_parameters_in_synpred15_Go1565 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_identifierList_in_synpred19_Go1635 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_channel_in_synpred24_Go1794 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_sendChannel_in_synpred25_Go1798 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_literal_in_synpred47_Go2300 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_qualifiedIdent_in_synpred48_Go2304 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_methodExpr_in_synpred49_Go2308 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_packageName_in_synpred56_Go2381 = new BitSet(new long[]{0x4000000000000000L});
    public static final BitSet FOLLOW_62_in_synpred56_Go2383 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_key_in_synpred66_Go2523 = new BitSet(new long[]{0x8000000000000000L});
    public static final BitSet FOLLOW_63_in_synpred66_Go2525 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_fieldName_in_synpred67_Go2551 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_operand_in_synpred68_Go2630 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_conversion_in_synpred69_Go2634 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_selector_in_synpred70_Go2642 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_index_in_synpred71_Go2646 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_slice_in_synpred72_Go2650 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_typeAssertion_in_synpred73_Go2654 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expressionStmt_in_synpred96_Go3193 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_incDecStmt_in_synpred97_Go3197 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_assignment_in_synpred98_Go3201 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_simpleStmt_in_synpred100_Go3341 = new BitSet(new long[]{0x0001000000000000L});
    public static final BitSet FOLLOW_48_in_synpred100_Go3343 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_exprSwitchStmt_in_synpred103_Go3376 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_simpleStmt_in_synpred104_Go3396 = new BitSet(new long[]{0x0001000000000000L});
    public static final BitSet FOLLOW_48_in_synpred104_Go3398 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_simpleStmt_in_synpred109_Go3475 = new BitSet(new long[]{0x0001000000000000L});
    public static final BitSet FOLLOW_48_in_synpred109_Go3477 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_condition_in_synpred115_Go3601 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_forClause_in_synpred116_Go3605 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_rangeClause_in_synpred117_Go3609 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_initStmt_in_synpred118_Go3639 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_postStmt_in_synpred120_Go3657 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_sendExpr_in_synpred124_Go3783 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_type_in_synpred133_Go3966 = new BitSet(new long[]{0x0010000000000002L});
    public static final BitSet FOLLOW_52_in_synpred133_Go3970 = new BitSet(new long[]{0x0088540A02644000L});
    public static final BitSet FOLLOW_expressionList_in_synpred133_Go3972 = new BitSet(new long[]{0x0000000000000002L});

}